Struct SqsQueue 

pub struct SqsQueue { /* private fields */ }

A subscription descriptor for one SQS queue.

Accepts a queue URL or a queue name (resolved through GetQueueUrl on subscribe). Implements SubscriptionSource, so it can sit inline in the #[subscriber(..)] decorator:

use std::time::Duration;

use ruststream_sqs_sns::prelude::*;

#[subscriber(
    SqsQueue::new("orders")
        .wait(Duration::from_secs(20))
        .visibility(Duration::from_secs(30))
)]
async fn handle(order: &Order<'_>) -> HandlerOutcome {
    if order.0.is_empty() {
        return HandlerOutcome::drop();
    }
    HandlerOutcome::ack()
}

#[app]
fn service() -> impl App {
    RustStream::new(AppInfo::new("orders", "0.1.0")).with_broker(SqsBroker::new(), |b| {
        b.include(handle);
    })
}

The same options are also reachable at the mount site through SqsSubscription, which is where they go when the registration names a batch size first.

max_attempts(n) and dead_letter(name) right after include are one setting here, the queue’s redrive policy: the subscription writes both onto the queue when it opens, and SQS counts the receives and moves a spent delivery to the dead-letter queue itself. Half a policy is SqsError::IncompleteRedrive at startup.

use ruststream_sqs_sns::prelude::*;
use serde::Deserialize;

#[derive(Deserialize)]
struct Invoice {
    id: u64,
}

#[subscriber(SqsQueue::new("invoices"))]
async fn settle(invoice: &Invoice) -> HandlerOutcome {
    if invoice.id == 0 {
        return HandlerOutcome::retry();
    }
    HandlerOutcome::ack()
}

#[app]
fn service() -> impl App {
    RustStream::new(AppInfo::new("invoices", "0.1.0")).with_broker(SqsBroker::new(), |b| {
        b.include(settle)
            .max_attempts(nonzero!(3u32))
            .dead_letter("invoices-dead");
    })
}

Implementations

impl SqsQueue

pub fn new(queue: impl Into<String>) -> Self

Names the queue by URL (https://sqs...) or by name.

pub fn wait(self, wait: Duration) -> Self

Long-polling wait per receive call. Defaults to the protocol maximum of 20 seconds; values above it are rejected before any I/O.

pub fn visibility(self, visibility: Duration) -> Self

The visibility timeout requested per receive; the crate extends it in the background while a handler holds the message. Defaults to the queue’s configured timeout.

SQS takes whole seconds from one second to twelve hours. A value outside that range is rejected before any I/O, and a fraction of a second rounds up to the next whole second.

pub fn create_if_missing(self) -> Self

Creates the queue on subscribe when it does not exist yet (a name ending in .fifo creates a FIFO queue with content-based deduplication). Meant for local development and tests; production queues are usually managed as infrastructure.

pub fn queue(&self) -> &str

The queue URL or name this descriptor resolves.

Trait Implementations

impl Clone for SqsQueue

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SqsQueue

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

Formats the value using the given formatter.

impl Eq for SqsQueue

impl FromName for SqsQueue

A queue is named and nothing more, so a definition may fix the kind and leave the name to the mount site: #[subscriber(SqsQueue)] on the handler, .name("orders") where it is included. Every polling option keeps its default there, and the mount-site steps of SqsSubscription change them.

fn from_name(name: impl Into<Cow<'static, str>>) -> Self

Builds the source bound to name.

impl PartialEq for SqsQueue

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for SqsQueue

impl SubscriptionSource<ConnectedSqsBroker> for SqsQueue

type Subscriber = SqsSubscriber

The subscriber type this source opens.

type Copies = BrokerMoves

Who publishes the copies this subscription’s retries are made of, and who names where they go: AddressedCopies, NamedCopies or BrokerMoves.

fn name(&self) -> &str

The name (subject / channel) this subscription binds to.

async fn subscribe( self, connected: &ConnectedSqsBroker, ) -> Result<SqsSubscriber, SqsError>

Opens the subscription against the connected broker. Called once at startup.

fn declare_retry(self, declaration: &RetryDeclaration) -> Self

Takes the registration’s retry declaration into the descriptor, before the subscription opens.

fn channel_bindings(&self) -> Bindings

What this subscription adds to its channel in the generated AsyncAPI document.

fn declare_retry_on( &self, connected: &C, declaration: &RetryDeclaration, ) -> Result<(), DeclareRetryError>

Carries the registration’s declaration to the broker, at the same point and before the subscription opens.

fn operation_bindings(&self) -> Bindings

What this subscription adds to its receive operation in the document.

fn message_bindings(&self) -> Bindings

What this subscription adds to the messages that arrive on it.