Struct TrackedPublisher 

pub struct TrackedPublisher<Live, DB: Database, Records> { /* private fields */ }

A publisher that records what it publishes under a registered name, from wrap.

It publishes as the publisher it wraps does, with the same payload form and options. A message under a registered name is recorded first and carries OUTBOX_ID_HEADER; one under any other name goes out as it is.

Examples

pub async fn serve(pool: PgPool) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    let tracking = outbox! { pool: pool, "orders" => OrderOutbox };
    let broker = MemoryBroker::new().bindable();
    let egress = broker.bind(Publish);
    let running = RustStream::new(AppInfo::new("orders", "0.1.0"))
        .with_broker(broker, |b| {
            b.include(fulfil);
        })
        .start()
        .await?;

    let publisher = tracking.wrap(running.publisher(egress).await?);
    publisher.message(&OrderPlaced { id: 7 }).publish().await?;

    running.shutdown().await?;
    Ok(())
}

Trait Implementations

impl<Live: Clone, DB: Database, Records: Copy> Clone for TrackedPublisher<Live, DB, Records>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Live: Debug, DB: Database, Records: Debug> Debug for TrackedPublisher<Live, DB, Records>

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

Formats the value using the given formatter.

impl<Live, DB, Records> Publisher for TrackedPublisher<Live, DB, Records>

where Live: Publisher, DB: Database, Records: RecordList<DB>,

type Payload = <Live as Publisher>::Payload

How this transport consumes the payload: Lend where it reads the bytes and keeps nothing, Take where its client keeps them.

type Error = TrackedPublishError<<Live as Publisher>::Error>

The error type returned by publish.

type Options = <Live as Publisher>::Options

The broker’s per-message settings: a QoS, a priority, an ordering key, whatever this transport lets one message differ from the next in.

async fn publish( &self, msg: OutgoingFor<'_, Self::Payload>, options: Option<&Self::Options>, ) -> Result<(), Self::Error>

Publishes a message to the broker, with the per-message settings the call site adjusted.

fn base_headers(&self) -> Option<&HeaderMap>

The headers this publisher contributes to every message it sends, underneath whatever the message itself names.