mod connect;
use bornera_core::{
CancelOutcome, CloseReason, FrameDecoder, InputDisposition, OperationId, OperationOptions,
OperationPermit,
};
use calandria::{Duty, EventBatchDrain, Moment, Next, Retained, Span, Turn, WaitOutcome};
use crate::{
ConnectionAccessError, ConnectionCommitError, ConnectionEvent, ConnectionPort,
ConnectionPulseHandle, ConnectionSet, ConnectionSetSnapshot, ConnectionSlotSnapshot,
ConnectionToken, EngineCommitError, EngineError, EngineInvariant, EngineOutcome,
InboundClassifier, OutboundFrame, OwnerFailure, RegisteredTransport, TcpTransport,
TransportState,
};
#[derive(Debug)]
pub struct StandaloneConnection<D, C, T = TcpTransport>
where
D: FrameDecoder,
T: RegisteredTransport,
{
pub(crate) set: ConnectionSet<D, C, T>,
pub(crate) connection: ConnectionToken,
}
impl<D, C, T> StandaloneConnection<D, C, T>
where
D: FrameDecoder,
D::Frame: Retained,
C: InboundClassifier<D::Frame>,
T: RegisteredTransport,
{
pub const fn token(&self) -> ConnectionToken {
self.connection
}
pub fn port(&self) -> ConnectionPort {
ConnectionPort::new(self.connection, self.set.sender.clone())
}
pub fn wake_handle(&self) -> calandria::WakeHandle {
self.set.wake_handle()
}
pub fn pulse_handle(&self) -> ConnectionPulseHandle {
self.set.pulse_handle()
}
pub fn reserve(
&mut self,
now: Moment,
options: OperationOptions,
) -> Result<OperationPermit, bornera_core::ReserveError> {
match self.set.reserve(self.connection, now, options) {
Ok(permit) => Ok(permit),
Err(crate::ConnectionReserveError::Rejected(error)) => Err(error),
Err(crate::ConnectionReserveError::StaleConnection) => {
Err(bornera_core::ReserveError::OwnerPoisoned)
}
}
}
pub fn commit(
&mut self,
permit: OperationPermit,
frame: OutboundFrame,
) -> Result<OperationId, EngineCommitError<OutboundFrame>> {
match self.set.commit(self.connection, permit, frame) {
Ok(operation) => Ok(operation),
Err(ConnectionCommitError::Connection(error)) => Err(error),
Err(ConnectionCommitError::StaleConnection { permit, frame }) => {
Err(EngineCommitError::OwnerFailed {
reason: OwnerFailure::OwnerInvariant,
permit,
frame,
})
}
}
}
pub fn open_admission(&mut self) -> Result<InputDisposition, EngineError> {
self.set
.open_admission(self.connection)
.map_err(standalone_error)
}
pub fn cancel(&mut self, operation: OperationId) -> Result<CancelOutcome, EngineError> {
self.set
.cancel(self.connection, operation)
.map_err(standalone_error)
}
pub fn begin_drain(
&mut self,
deadline: calandria::Deadline,
) -> Result<InputDisposition, EngineError> {
self.set
.begin_drain(self.connection, deadline)
.map_err(standalone_error)
}
pub fn finalize(&mut self, reason: CloseReason) -> Result<InputDisposition, EngineError> {
self.set
.finalize(self.connection, reason)
.map_err(standalone_error)
}
pub fn drain_outcomes(
&mut self,
) -> Result<EventBatchDrain<'_, EngineOutcome<D::Frame>>, EngineError> {
self.set
.drain_outcomes(self.connection)
.map_err(standalone_error)
}
pub fn drain_events(&mut self) -> Result<EventBatchDrain<'_, ConnectionEvent>, EngineError> {
self.set
.drain_events(self.connection)
.map_err(standalone_error)
}
pub fn snapshot(&self) -> Result<ConnectionSlotSnapshot, EngineError> {
self.set
.connection_snapshot(self.connection)
.map_err(standalone_error)
}
pub fn set_snapshot(&self) -> ConnectionSetSnapshot {
self.set.snapshot()
}
pub fn is_transport_open(&self) -> Result<bool, EngineError> {
self.set
.is_transport_open(self.connection)
.map_err(standalone_error)
}
pub fn turn_component(&mut self, now: Moment) -> Result<Turn, EngineError> {
self.ensure_running()?;
let turn = self.set.turn_component(now)?;
let snapshot = self
.set
.connection_snapshot(self.connection)
.map_err(standalone_error)?;
if let Some(reason) = snapshot.owner_failure {
return Err(EngineError::OwnerFailed(reason));
}
Ok(if snapshot.transport == TransportState::Closed {
Turn::new(turn.work(), Next::Stop)
} else {
turn
})
}
pub fn poll_io(&mut self, maximum: Span) -> Result<WaitOutcome, EngineError> {
self.ensure_running()?;
self.set.poll_io(maximum)
}
fn ensure_running(&self) -> Result<(), EngineError> {
let snapshot = self
.set
.connection_snapshot(self.connection)
.map_err(standalone_error)?;
snapshot
.owner_failure
.map_or(Ok(()), |reason| Err(EngineError::OwnerFailed(reason)))
}
}
fn standalone_error(error: ConnectionAccessError) -> EngineError {
match error {
ConnectionAccessError::StaleConnection => {
EngineError::Invariant(EngineInvariant::ResourceToken)
}
ConnectionAccessError::Owner(source) => source,
}
}
impl<D, C, T> Duty for StandaloneConnection<D, C, T>
where
D: FrameDecoder,
D::Frame: Retained,
C: InboundClassifier<D::Frame>,
T: RegisteredTransport,
{
type Error = EngineError;
fn turn(&mut self, now: Moment) -> Result<Turn, Self::Error> {
self.turn_component(now)
}
}