Struct StandbyController 

pub struct StandbyController {
    state: Arc<Mutex<StandbyState>>,
}

Controls the engine standby → draining → active lifecycle.

In standby mode, orders are queued in memory. On promote(), the current queue is handed off for draining and the controller enters a draining phase; orders arriving during that phase continue to queue until finish_drain() transitions the controller to active mode, after which try_enqueue() returns NotStandby and callers forward directly to the engine.

Fields

state: Arc<Mutex<StandbyState>>

Implementations

impl StandbyController

pub fn new_standby(capacity: usize) -> (Self, Receiver<()>)

Create a new controller in standby mode. Returns the controller and a future that resolves when promote is called.

pub fn new_active() -> Self

Create a controller that starts in active mode (no standby).

pub async fn is_standby(&self) -> bool

Returns true if the controller is currently in standby or draining mode (i.e., not yet fully active — orders are still being queued).

pub async fn is_promoted(&self) -> bool

Returns true if promote() has been called (in Draining or Active state).

pub async fn try_enqueue(&self, request: UnifiedEngineRequest) -> EnqueueResult

Try to enqueue an order. Returns the appropriate result for each state:

• Queued: order was accepted into the standby queue
• NotStandby(request): not in standby mode, caller should forward to engine directly
• QueueFull(request): queue at capacity, caller should return 503

pub async fn promote(&self) -> PromoteResult

Promote from standby to draining. Sends the promote signal so any waiting tasks (engine, batcher, etc.) unblock.

Orders remain in the controller — call take_drain_batch() to retrieve them for draining. New orders arriving during drain are still queued (not forwarded directly) to preserve ordering.

pub async fn take_drain_batch(&self) -> Vec<UnifiedEngineRequest>

Take a batch of orders to drain into the engine. Returns queued orders and keeps the controller in Draining state. When the returned vec is empty, transitions to Active. Call this in a loop until it returns an empty vec.

pub async fn drain_to( orders: Vec<UnifiedEngineRequest>, engine_tx: &Sender<UnifiedEngineRequest>, ) -> (usize, Vec<UnifiedEngineRequest>)

Drain queued orders into the engine channel. Returns (sent_count, unsent_orders) — unsent orders are returned on channel failure so callers can retry or persist them.

Trait Implementations

impl Clone for StandbyController

fn clone(&self) -> StandbyController

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl StandbyPromoter for StandbyController

fn promote<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = StandbyPromoteOutcome> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,