Struct NatsQueue 

pub struct NatsQueue { /* private fields */ }

A queue implementation using NATS JetStream

Implementations

impl NatsQueue

pub fn new( stream_name: String, nats_server: String, dequeue_timeout: Duration, ) -> Self

Create a new NatsQueue with the default “worker-group” consumer

pub fn new_without_consumer( stream_name: String, nats_server: String, dequeue_timeout: Duration, ) -> Self

Create a new NatsQueue without a consumer (publisher-only mode)

pub fn new_with_consumer( stream_name: String, nats_server: String, dequeue_timeout: Duration, consumer_name: String, ) -> Self

Create a new NatsQueue with a specific consumer name for broadcast pattern Each consumer with a unique name will receive all messages independently

pub async fn connect(&mut self) -> Result<()>

Connect to the NATS server and set up the stream and consumer

pub async fn connect_with_reset(&mut self, reset_stream: bool) -> Result<()>

Connect to the NATS server and set up the stream and consumer, optionally resetting the stream

pub async fn ensure_connection(&mut self) -> Result<()>

Ensure we have an active connection

pub async fn close(&mut self) -> Result<()>

Close the connection when done

pub async fn shutdown(&mut self, consumer_name: Option<String>) -> Result<()>

Shutdown the consumer by deleting it from the stream and closing the connection This permanently removes the consumer from the server

If consumer_name is provided, that specific consumer will be deleted instead of the current consumer. This allows deletion of other consumers on the same stream.

pub async fn count_consumers(&mut self) -> Result<usize>

Count the number of consumers for the stream

pub async fn list_consumers(&mut self) -> Result<Vec<String>>

List all consumer names for the stream

pub async fn enqueue_task(&mut self, task_data: Bytes) -> Result<()>

Enqueue a task using the provided data

pub async fn dequeue_task( &mut self, timeout: Option<Duration>, ) -> Result<Option<Bytes>>

Dequeue and return a task as raw bytes

pub async fn get_queue_size(&mut self) -> Result<u64>

Get the number of messages currently in the queue

pub async fn get_stream_messages(&mut self) -> Result<u64>

Get the total number of messages currently in the stream

pub async fn purge_up_to_sequence(&self, sequence: u64) -> Result<()>

Purge messages from the stream up to (but not including) the specified sequence number This permanently removes messages and affects all consumers of the stream

pub async fn purge_acknowledged(&mut self) -> Result<()>

Purge messages from the stream up to the minimum acknowledged sequence across all consumers This finds the lowest acknowledged sequence number across all consumers and purges up to that point

Trait Implementations

impl EventPublisher for NatsQueue

fn subject(&self) -> String

The base subject used for this implementation of the EventPublisher.

fn publish<'life0, 'life1, 'async_trait>( &'life0 self, event_name: impl 'async_trait + AsRef<str> + Send + Sync, event: &'life1 (impl 'async_trait + Serialize + Send + Sync), ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Publish a single event to the event plane. The event_name will be . concatenated with the base subject provided by the implementation.

fn publish_bytes<'life0, 'async_trait>( &'life0 self, event_name: impl 'async_trait + AsRef<str> + Send + Sync, bytes: Vec<u8>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Publish a single event as bytes to the event plane. The event_name will be . concatenated with the base subject provided by the implementation.