Struct OpenStreamEnt 

pub(crate) struct OpenStreamEnt {
    pub(crate) sink: StreamQueueSender,
    pub(crate) dropped: u16,
    pub(crate) cmd_checker: Box<dyn CmdChecker + Send + 'static>,
    flow_ctrl: StreamFlowCtrl,
    rx: StreamUnobtrusivePeeker<Receiver<AnyRelayMsg, MpscSpec>>,
    flow_ctrl_waker: Option<Waker>,
}

Entry for an open stream

(For the purposes of this module, an open stream is one where we have not sent or received any message indicating that the stream is ended.)

Fields

sink: StreamQueueSender

Sink to send relay cells tagged for this stream into.

dropped: u16

Number of cells dropped due to the stream disappearing before we can transform this into an EndSent.

cmd_checker: Box<dyn CmdChecker + Send + 'static>

A CmdChecker used to tell whether cells on this stream are valid.

flow_ctrl: StreamFlowCtrl

Flow control for this stream.

rx: StreamUnobtrusivePeeker<Receiver<AnyRelayMsg, MpscSpec>>

Stream for cells that should be sent down this stream.

flow_ctrl_waker: Option<Waker>

Waker to be woken when more sending capacity becomes available (e.g. receiving a SENDME).

Implementations

impl OpenStreamEnt

pub(crate) fn project<'pin>( self: Pin<&'pin mut Self>, ) -> __OpenStreamEntProjection<'pin>

pub(crate) fn project_ref<'pin>( self: Pin<&'pin Self>, ) -> __OpenStreamEntProjectionRef<'pin>

impl OpenStreamEnt

pub(crate) fn can_send<M: RelayMsg>(&self, msg: &M) -> bool

Whether this stream is ready to send msg.

pub(crate) fn put_for_incoming_sendme( &mut self, msg: UnparsedRelayMsg, ) -> Result<()>

Handle an incoming sendme.

On failure, return an error: the caller should close the stream or circuit with a protocol error.

fn approx_stream_bytes_buffered(&self) -> usize

The approximate number of stream inbound data bytes buffered.

pub(crate) fn maybe_send_xon( &mut self, rate: XonKbpsEwma, ) -> Result<Option<Xon>>

Check if we should send an XON message.

If we should, then returns the XON message that should be sent. Returns an error if XON/XOFF messages aren’t supported for this type of flow control.

pub(crate) fn maybe_send_xoff(&mut self) -> Result<Option<Xoff>>

Check if we should send an XOFF message.

If we should, then returns the XOFF message that should be sent. Returns an error if XON/XOFF messages aren’t supported for this type of flow control.

pub(crate) fn handle_incoming_xon( &mut self, msg: UnparsedRelayMsg, ) -> Result<()>

Handle an incoming XON message.

On failure, return an error: the caller should close the stream or circuit with a protocol error.

pub(crate) fn handle_incoming_xoff( &mut self, msg: UnparsedRelayMsg, ) -> Result<()>

Handle an incoming XOFF message.

On failure, return an error: the caller should close the stream or circuit with a protocol error.

pub(crate) fn about_to_send(&mut self, msg: &AnyRelayMsg) -> Result<()>

Inform the flow control code that we’re about to send msg. Should be called at the point we’ve fully committed to sending the message. Returns an error if we can’t send msg and should close the circuit.

Trait Implementations

impl Debug for OpenStreamEnt

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'pin> Unpin for OpenStreamEnt

where PinnedFieldsOf<__OpenStreamEnt<'pin>>: Unpin,