Struct ResequencerService 

pub struct ResequencerService { /* private fields */ }

Continuation-boundary resequencer.

Owns an actor task (consumes from input channel, calls policy.accept(input)) and a post-driver task (consumes ready exchanges, drives post_continuation). Service::call(input) sends into the bounded input channel and returns an ack.

Implementations

impl ResequencerService

pub fn new( policy: Arc<dyn ResequencePolicy>, post_continuation: BoxCloneService<Exchange, Exchange, CamelError>, input_capacity: usize, post_lifecycles: Vec<Arc<dyn StepLifecycle>>, ) -> Self

Create a new resequencer with the given policy, continuation, and post-step lifecycles.

• input_capacity — bounded channel capacity (default 1024). Backpressure propagates to the caller via send().await.
• post_lifecycles — lifecycle handles for steps AFTER the resequencer (drained in shutdown after post-driver quiesces; empty for Task 1a).

Panics

Panics if called outside a Tokio runtime context: new() spawns the actor and post-driver tasks via tokio::spawn.

pub fn with_config( policy: Arc<dyn ResequencePolicy>, post_continuation: BoxCloneService<Exchange, Exchange, CamelError>, input_capacity: usize, post_lifecycles: Vec<Arc<dyn StepLifecycle>>, config: ResequencerConfig, ) -> Self

Full constructor with explicit ResequencerConfig.

Panics

Panics if called outside a Tokio runtime context.

Trait Implementations

impl Clone for ResequencerService

fn clone(&self) -> ResequencerService

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ResequencerService

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

Formats the value using the given formatter.

impl Service<Exchange> for ResequencerService

type Response = Exchange

Responses given by the service.

type Error = CamelError

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<Exchange, CamelError>> + Send>>

The future response value.

fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), CamelError>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, input: Exchange) -> Self::Future

Process the request and return the response asynchronously.

impl StepLifecycle for ResequencerService

fn shutdown<'life0, 'async_trait>( &'life0 self, reason: StepShutdownReason, ) -> Pin<Box<dyn Future<Output = Result<(), CamelError>> + Send + 'async_trait>>

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

Idempotent shutdown with this ordering:

1. Set shutdown flag; close/drop input_tx so actor sees EOF.
2. Await actor JoinHandle (bounded deadline).
3. policy.flush() → emit remaining in order via post-driver.
4. Close post-driver channel sender so its loop sees EOF.
5. Await post-driver JoinHandle with 5s deadline.
6. Drain post-step lifecycles (oracle Fix 2).

fn name(&self) -> &'static str

Stable name for logging/diagnostics.