Struct JetStreamBackend 

pub struct JetStreamBackend { /* private fields */ }

A connected adapter for one team.

Implementations

impl JetStreamBackend

pub const NAME: &'static str = "jetstream"

pub async fn connect(config: &Config, team_id: Uuid) -> BusResult<Self>

Connect and adopt the team’s stream. Does not create it: that is provision, an operator action with a different credential.

pub async fn provision(config: &Config, team_id: Uuid) -> BusResult<Provisioned>

Create a team’s body stream, or find it. Operator action: run with the provisioning credential, not the one the server runs with.

An existing stream keeps its limits, whatever config asks for: a routine retry must never shrink or grow a quota on the quiet. Provisioned::created and Provisioned::differs_from tell the caller what happened, and Self::update_quotas is the explicit way to change them.

pub async fn provision_inbox( config: &Config, team_id: Uuid, ) -> BusResult<Provisioned>

Create or find a team’s inbox stream. Same operator action and same credential as provision; separate so a deployment can see what each stream costs.

pub async fn check_update( config: &Config, team_id: Uuid, kind: StreamKind, ) -> BusResult<QuotaChange>

What changing a stream’s quotas would do, without doing it: the limits it has now (what a rollback restores), what it holds, and the extra bytes the broker would have to reserve. Refused when the stream already holds more than the new ceiling would allow, since a ceiling below the current contents would make the next write fail (bodies) or start dropping (references) at once.

pub async fn update_quotas( config: &Config, team_id: Uuid, kind: StreamKind, ) -> BusResult<Provisioned>

Change an existing stream’s quotas to what config asks for: the explicit counterpart of the retry that keeps them. Runs Self::check_update first. The check is a snapshot: a publisher can add to the stream between it and the update, so the outcome carries the contents read back afterwards and the caller says so when they exceed the new ceiling. Neither stream loses data to that race: the body stream discards new writes when full, and an inbox reference the broker drops is rebuilt from Postgres, which is its authority.

pub async fn apply_update( config: &Config, team_id: Uuid, kind: StreamKind, change: &QuotaChange, ) -> BusResult<Provisioned>

Apply a change that Self::check_update already vetted.

pub async fn storage_account(config: &Config) -> BusResult<StorageAccount>

The broker’s storage account as it stands: bytes used, bytes reserved by every stream’s max_bytes, and the store’s budget (None when the account is unlimited). Lets a caller refuse a change that could not be reserved before touching anything.

pub async fn publish_reference( &self, recipient_key: &str, event_id: Uuid, payload: &str, ) -> Published

Publish one reference to a recipient’s own subject.

Deduplicated on the event id, so a retry of the same reference is the same notification rather than a second one.

pub async fn fetch_references( &self, recipient_key: &str, limit: usize, ) -> BusResult<Vec<InboxRef>>

Take up to limit references without acknowledging any of them. Acknowledgement happens only once the receipt is committed.

pub async fn ack_reference(&self, ack_subject: &str) -> BusResult<()>

Acknowledge one reference by the subject it was offered on. Sent after the receipt has been committed, never before.

pub async fn inbox_status(&self, recipient_key: &str) -> BusResult<InboxStatus>

What this recipient’s consumer holds. A missing consumer is a fact, not an empty inbox.

pub async fn deprovision(config: &Config, team_id: Uuid) -> BusResult<()>

Remove a team’s stream. Operator action, and a destructive one: it drops every body the stream holds.

pub fn stream(&self) -> &str

pub async fn reachable(config: &Config) -> bool

Can this process reach the broker at all? For health checks, which is why it opens and drops a connection rather than reusing a team’s: it answers a question about the deployment, not about a stream.

Trait Implementations

impl Clone for JetStreamBackend

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl MessagingBackend for JetStreamBackend

fn name(&self) -> &'static str

Name recorded on the conversation and the outbox row.

async fn publish(&self, envelope: Envelope) -> Published

Persist a body. Must be idempotent on publish_key: presented the same key twice, it returns the same locator rather than storing twice.

async fn fetch( &self, locator: &Locator, message_id: Uuid, ) -> BusResult<Option<String>>

Read a body back by locator, for history.

async fn retain(&self, _before: DateTime<Utc>) -> BusResult<u64>

Drop a body the retention policy no longer keeps. Returns how many were removed.

async fn reconcile(&self, envelope: &Envelope) -> BusResult<Option<Locator>>

Settle an attempt that ended without an answer.