Struct CoreWildcard 

pub struct CoreWildcard { /* private fields */ }

A pattern subscribed to over Core NATS: orders.*, orders.>, >.

The same subscription as CoreSubject, on many subjects instead of one. That is the whole difference between the two types, and it is the difference that matters to a retry: a pattern names many subjects and none of them in particular, so this subscription cannot say where a copy of a delivery would reach it again. The mount site says it instead, with .out_retry(Publish).to("orders.created") or with a transform that reads the delivery and names its own subject; a registration that says neither refuses to start.

Examples

use std::time::Duration;

use ruststream_nats::prelude::*;
use serde::Deserialize;

#[derive(Deserialize)]
struct Order {
    id: u64,
    paid: bool,
}

#[subscriber(CoreWildcard::new("orders.*").queue_group("auditors"))]
async fn audit(order: &Order) -> HandlerOutcome {
    if order.paid {
        return HandlerOutcome::ack();
    }
    HandlerOutcome::retry_after(Duration::from_secs(30))
}

#[ruststream::app]
fn app() -> impl App {
    RustStream::new(AppInfo::new("audit", "0.1.0")).with_broker(
        NatsBroker::new("nats://localhost:4222"),
        |b| {
            // A pattern is no destination, so the mount site names where a delayed copy goes.
            b.include(audit)
                .max_attempts(nonzero!(5u32))
                .dead_letter("orders.dead")
                .out_retry(Publish)
                .to("orders.audit");
        },
    )
}

Implementations

impl CoreWildcard

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

Subscribes to the pattern subject over Core NATS.

pub fn queue_group(self, name: impl Into<String>) -> Self

Load-balances the pattern across a queue group, exactly as CoreSubject::queue_group does for one subject.

Trait Implementations

impl Clone for CoreWildcard

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 CoreWildcard

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

Formats the value using the given formatter.

impl Eq for CoreWildcard

impl IntoSource for CoreWildcard

type Source = CoreWildcard

The source the constructor stores.

fn into_source(self) -> Self

Builds the source.

impl NatsSubscription for CoreWildcard

fn subject(&self) -> &str

The subject pattern this subscription receives messages on.

fn ensure_subject(&self) -> Result<(), NatsError>

The one thing about a subscription the types cannot settle: the subject is a string the caller supplies, often from configuration, and a descriptor constructor is the expression a #[subscriber(..)] attribute writes, so it cannot hand back a Result. Every subscribe implementation calls this before it does any work.

impl PartialEq for CoreWildcard

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for CoreWildcard

impl SubscriptionSource<ConnectedNatsBroker> for CoreWildcard

type Subscriber = NatsSubscriber

The subscriber type this source opens.

type Copies = NamedCopies

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: &ConnectedNatsBroker, ) -> Result<Self::Subscriber, NatsError>

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

fn operation_bindings(&self) -> Bindings

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

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

where Self: Sized,

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

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 channel_bindings(&self) -> Bindings

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

fn message_bindings(&self) -> Bindings

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