Skip to main content

bornera/
slot_close.rs

1//! Physical transport closure for one selector-free connection slot.
2
3use bornera_core::{ConnectionInput, FrameDecoder};
4use calandria::Retained;
5
6use crate::{
7    CloseDirective, ConnectionSlot, EngineError, InboundClassifier, TransportState,
8    slot::ShutdownState,
9};
10
11impl<D, C> ConnectionSlot<D, C>
12where
13    D: FrameDecoder,
14    D::Frame: Retained,
15    C: InboundClassifier<D::Frame>,
16{
17    pub(crate) fn take_close_request(&mut self) -> Option<CloseDirective> {
18        self.close_request
19            .is_some_and(CloseDirective::settlement_ready)
20            .then(|| self.close_request.take())
21            .flatten()
22    }
23
24    pub(crate) fn restore_close_request(&mut self, directive: CloseDirective) {
25        self.close_request = Some(directive);
26    }
27
28    pub(crate) fn abort_transport(&mut self) {
29        self.transport_state = TransportState::Closed;
30        self.drain_deadline = None;
31        self.close_request = None;
32    }
33
34    /// Confirms that the owner released its physical capability after a close request.
35    ///
36    /// Returns `false` when no settle-ready close request was pending. A graceful
37    /// request becomes settle-ready only after bounded shutdown progression completes
38    /// or reaches its deadline. Publication failure latches the slot and conservatively
39    /// aborts its transport state.
40    pub fn settle_transport_closed(&mut self) -> bool {
41        let Some(directive) = self.take_close_request() else {
42            return false;
43        };
44        match directive {
45            CloseDirective::Abort => self.abort_transport(),
46            CloseDirective::Core {
47                reason,
48                shutdown: ShutdownState::Immediate | ShutdownState::Complete,
49            } => {
50                if let Err(error) = self.confirm_transport_closed(reason) {
51                    self.latch_failure(&error);
52                    self.abort_transport();
53                }
54            }
55            CloseDirective::Core { .. } => return false,
56        }
57        true
58    }
59
60    fn confirm_transport_closed(
61        &mut self,
62        reason: bornera_core::CloseReason,
63    ) -> Result<(), EngineError> {
64        self.transport_state = TransportState::Closed;
65        let transition = self
66            .core
67            .apply(ConnectionInput::EpochClosed {
68                epoch: self.core.epoch(),
69            })
70            .map_err(EngineError::Core)?;
71        self.interpret_unit(transition)?;
72        self.publish_closed(reason)
73    }
74}