Struct InboxThreads 

pub struct InboxThreads { /* private fields */ }

The dedicated threads of an InboxQueue subscription, and the connections each one opens for its handlers’ queries: what InboxSettings::on_threads mounts.

A handler on one of the threads queries through Ctx<keys::Pool<..>> on a pool of the thread’s own, with the service pool’s options and connections connections at most, one unless set. Its connections open on the thread and close with it. Knowing both numbers, the subscription counts threads × connections against the broker’s connection_limit when it opens.

Examples

use ruststream::nonzero;
use ruststream_sqlx::prelude::*;
use sqlx::{PgPool, Postgres};

#[subscriber(InboxQueue::<LedgerJob>::new("entries"))]
async fn post(entry: &Entry, Ctx(pool): Ctx<keys::Pool<Postgres>>) -> HandlerOutcome {
    let posted = sqlx::query("INSERT INTO postings (amount) VALUES ($1)")
        .bind(entry.amount)
        .execute(&pool)
        .await;
    if posted.is_ok() { HandlerOutcome::ack() } else { HandlerOutcome::retry() }
}

pub fn app(pool: PgPool) -> RustStream {
    // Eight threads, an account's entries on one of them, one connection each.
    let threads = InboxThreads::new(nonzero!(8)).by_key();
    RustStream::new(AppInfo::new("ledger", "0.1.0")).with_broker(SqlxBroker::new(pool), |b| {
        b.include(post.on_threads(threads));
    })
}

Implementations

impl InboxThreads

pub const fn new(count: NonZeroUsize) -> Self

count dedicated threads, as threads(count), each opening one connection.

pub const fn by_key(self) -> Self

Sends the deliveries of one partition key to one thread, as threads(count, by_key), so a key keeps its order.

pub const fn connections(self, connections: NonZeroU32) -> Self

Opens connections connections at most on each thread, for its handlers’ queries.

A thread runs its deliveries one at a time, so one connection serves a handler that holds one connection at a time. A handler that holds two at once, or queries from tasks it spawns on its thread, needs one more for each.

Trait Implementations

impl Clone for InboxThreads

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for InboxThreads

impl Debug for InboxThreads

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

Formats the value using the given formatter.

impl Eq for InboxThreads

impl Hash for InboxThreads

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for InboxThreads

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for InboxThreads