Struct PartitionedQueue 

pub struct PartitionedQueue { /* private fields */ }

A deterministic set of physical queues for one hot logical queue.

Awa still stores and executes jobs from ordinary queue names. This helper gives producers and workers the same stable list of physical queues, so an application can partition one logical workload over several queues without hand-rolling naming and routing in every process.

Implementations

impl PartitionedQueue

pub fn new( logical_queue: impl Into<String>, partitions: usize, ) -> Result<Self, PartitionedQueueError>

Build a partitioned queue using Awa’s default physical queue naming.

One partition maps to the logical queue name itself. With more than one partition, partition 0 is still the logical queue name and later partitions are {logical_queue}__p1, {logical_queue}__p2, and so on. That keeps direct enqueues to the logical name consumable during a 1 -> N rollout.

pub fn from_physical_queues<I, S>( logical_queue: impl Into<String>, physical_queues: I, ) -> Result<Self, PartitionedQueueError>

where I: IntoIterator<Item = S>, S: Into<String>,

Build a partitioned queue from explicit physical queue names.

Use this when an application already has queue names it wants to keep, or when migrating an existing manually-fanned-out deployment to the shared helper.

pub fn logical_queue(&self) -> &str

Logical queue name used by the application.

pub fn physical_queues(&self) -> &[String]

Physical queues that must be declared on worker runtimes.

pub fn partitions(&self) -> usize

Number of physical queues in the partitioned queue.

pub fn queue_for_key(&self, key: impl AsRef<[u8]>) -> &str

Select a physical queue by stable routing key.

The same key always maps to the same physical queue. Partition routing domain-separates the hash used for queue-storage enqueue shards so partitions == enqueue_shards does not collapse keyed traffic onto one shard inside each partition.

pub fn queue_for_index(&self, index: usize) -> &str

Select a physical queue by caller-supplied sequence number.

This is useful for bulk producers that want round-robin partitioning and do not need per-key ordering.

pub fn route_opts_by_key( &self, opts: InsertOpts, key: impl AsRef<[u8]>, ) -> InsertOpts

Return insert options routed by key.

This sets both the physical queue and ordering_key, so per-key FIFO is preserved even if the selected physical queue later uses multiple queue-storage enqueue shards.

pub fn route_opts_by_index(&self, opts: InsertOpts, index: usize) -> InsertOpts

Return insert options routed by round-robin index.

Trait Implementations

impl AsRef<[String]> for PartitionedQueue

fn as_ref(&self) -> &[String]

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for PartitionedQueue

fn clone(&self) -> PartitionedQueue

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PartitionedQueue

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

Formats the value using the given formatter.

impl Eq for PartitionedQueue

impl<'a> IntoIterator for &'a PartitionedQueue

type Item = &'a String

The type of the elements being iterated over.

type IntoIter = Iter<'a, String>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for PartitionedQueue

fn eq(&self, other: &PartitionedQueue) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for PartitionedQueue