Enum RunOnceCmdInner 

enum RunOnceCmdInner {
    Send {
        leg: UniqId,
        cell: SendRelayCell,
        done: Option<Sender<Result<()>>>,
    },
    SendMsgAndInstallHandler {
        msg: Option<AnyRelayMsgOuter>,
        handler: Option<Box<dyn MetaCellHandler + Send + 'static>>,
        done: Sender<Result<()>>,
    },
    HandleSendMe {
        leg: UniqId,
        hop: HopNum,
        sendme: Sendme,
    },
    BeginStream {
        cell: Result<(SendRelayCell, StreamId)>,
        hop: HopLocation,
        leg: UniqId,
        done: Sender<Result<(StreamId, HopLocation, RelayCellFormat)>>,
    },
    MaybeSendXon {
        rate: XonKbpsEwma,
        stream_id: StreamId,
        hop: HopLocation,
    },
    CloseStream {
        hop: HopLocation,
        sid: StreamId,
        behav: CloseStreamBehavior,
        reason: TerminateReason,
        done: Option<Sender<Result<()>>>,
    },
    FirstHopClockSkew {
        answer: Sender<Result<ClockSkew, Bug>>,
    },
    RemoveLeg {
        leg: UniqId,
        reason: RemoveLegReason,
    },
    ConfluxHandshakeComplete {
        leg: UniqId,
        cell: SendRelayCell,
    },
    Link {
        circuits: Vec<Circuit>,
        answer: Sender<Result<Vec<Result<(), ConfluxHandshakeError>>>>,
    },
    Enqueue {
        leg: UniqId,
        msg: OooRelayMsg,
    },
    PaddingAction {
        leg: UniqId,
        padding_event: PaddingEvent,
    },
    CleanShutdown,
}

Instructions for running something in the reactor loop.

Run at the end of Reactor::run_once.

Variants

Send

Send a RELAY cell.

Fields

leg: UniqId

The leg the cell should be sent on.

cell: SendRelayCell

The cell to send.

done: Option<Sender<Result<()>>>

A channel for sending completion notifications.

SendMsgAndInstallHandler

Send a given control message on this circuit, and install a control-message handler to receive responses.

Fields

msg: Option<AnyRelayMsgOuter>

The message to send, if any

handler: Option<Box<dyn MetaCellHandler + Send + 'static>>

A message handler to install.

If this is None, there must already be a message handler installed

done: Sender<Result<()>>

A sender that we use to tell the caller that the message was sent and the handler installed.

HandleSendMe

Handle a SENDME message.

Fields

leg: UniqId

The leg the SENDME was received on.

hop: HopNum

The hop number.

sendme: Sendme

The SENDME message to handle.

BeginStream

Begin a stream with the provided hop in this circuit.

Uses the provided stream ID, and sends the provided message to that hop.

Fields

cell: Result<(SendRelayCell, StreamId)>

The cell to send.

hop: HopLocation

The location of the hop on the tunnel. We don’t use this (and Circuits shouldn’t need to worry about legs anyways), but need it so that we can pass it back in done to the caller.

leg: UniqId

The circuit leg to begin the stream on.

done: Sender<Result<(StreamId, HopLocation, RelayCellFormat)>>

Oneshot channel to notify on completion, with the allocated stream ID.

MaybeSendXon

Consider sending an XON message with the given rate.

Fields

rate: XonKbpsEwma

The drain rate to advertise in the XON message.

stream_id: StreamId

The ID of the stream to send the message on.

hop: HopLocation

The location of the hop on the tunnel.

CloseStream

Close the specified stream.

Fields

hop: HopLocation

The hop number.

sid: StreamId

The ID of the stream to close.

behav: CloseStreamBehavior

The stream-closing behavior.

reason: TerminateReason

The reason for closing the stream.

done: Option<Sender<Result<()>>>

A channel for sending completion notifications.

FirstHopClockSkew

Get the clock skew claimed by the first hop of the circuit.

Fields

answer: Sender<Result<ClockSkew, Bug>>

Oneshot channel to return the clock skew.

RemoveLeg

Remove a circuit leg from the conflux set.

Fields

leg: UniqId

The circuit leg to remove.

reason: RemoveLegReason

The reason for removal.

This is only used for conflux circuits that get removed before the conflux handshake is complete.

The RemoveLegReason is mapped by the reactor to a ConfluxHandshakeError that is sent to the initiator of the handshake to indicate the reason the handshake failed.

ConfluxHandshakeComplete

A circuit has completed the conflux handshake, and wants to send the specified cell.

This is similar to RunOnceCmdInner::Send, but needs to remain a separate variant, because in addition to instructing the reactor to send a cell, it also notifies it that the conflux handshake is complete on the specified leg. This enables the reactor to save the handshake result (Ok(())), and, if there are no other legs still in the handshake phase, send the result to the handshake initiator.

Fields

leg: UniqId

The circuit leg that has completed the handshake, This is the leg the cell should be sent on.

cell: SendRelayCell

The cell to send.

Link

Send a LINK cell on each of the unlinked circuit legs in the conflux set of this reactor.

Fields

circuits: Vec<Circuit>

The circuits to link into the tunnel

answer: Sender<Result<Vec<Result<(), ConfluxHandshakeError>>>>

Oneshot channel for notifying of conflux handshake completion.

Enqueue

Enqueue an out-of-order cell in ooo_msg.

Fields

leg: UniqId

The leg the entry originated from.

msg: OooRelayMsg

The out-of-order message.

PaddingAction

Take a padding-related event on a circuit leg.

Fields

leg: UniqId

The leg to event on.

padding_event: PaddingEvent

The event to take.

CleanShutdown

Perform a clean shutdown on this circuit.

Implementations

impl RunOnceCmdInner

fn from_circuit_cmd(leg: UniqId, cmd: CircuitCmd) -> Self

Create a RunOnceCmdInner out of a CircuitCmd and UniqId.

Trait Implementations

impl Debug for RunOnceCmdInner

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

Formats the value using the given formatter.

impl From<RunOnceCmdInner> for RunOnceCmd

fn from(value: RunOnceCmdInner) -> Self

Converts to this type from the input type.