Struct LocalDistributedQueue 

pub struct LocalDistributedQueue { /* private fields */ }

Local distributed queue implementation using multi-core parallelism

This is the default implementation that uses local channels for communication between partitions. Each partition runs on a separate tokio task, enabling efficient multi-core utilization.

Implementations

impl LocalDistributedQueue

pub fn new(partition_config: PartitionConfig) -> Self

Create a new local distributed queue with the specified partition configuration

pub fn auto() -> Self

Create a local distributed queue that automatically uses all CPU cores

pub fn partitioner(&self) -> &Arc<dyn Partitioner>

Get the partitioner

pub fn partition_config(&self) -> &PartitionConfig

Get the partition configuration

pub fn partition_receiver( &self, partition_id: PartitionId, ) -> Option<Arc<Mutex<Receiver<CommandEnvelope>>>>

Get the receiver for a specific partition (for worker tasks)

pub fn result_receiver(&self) -> Arc<Mutex<Receiver<CommandResult>>>

Get the result receiver (for coordinator to collect results)

pub fn result_sender(&self) -> Sender<CommandResult>

Get the result sender (for workers to send results)

Trait Implementations

impl DistributedQueue for LocalDistributedQueue

fn enqueue<'life0, 'async_trait>( &'life0 self, envelope: CommandEnvelope, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Enqueue a command to be processed by a worker

fn dequeue<'life0, 'async_trait>( &'life0 self, partition_id: PartitionId, ) -> Pin<Box<dyn Future<Output = Result<Option<CommandEnvelope>>> + Send + 'async_trait>>

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

Dequeue a command for processing (called by workers)

fn complete<'life0, 'async_trait>( &'life0 self, result: CommandResult, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Report command completion

fn num_partitions(&self) -> usize

Get the number of partitions

fn worker_id(&self) -> &WorkerId

Get the worker ID for this instance

fn is_coordinator(&self) -> bool

Check if this instance is a coordinator (can enqueue commands)

fn is_worker(&self) -> bool

Check if this instance is a worker (can dequeue and execute commands)