Struct ConnectedLapinBroker 

pub struct ConnectedLapinBroker { /* private fields */ }

The typed witness that Broker::connect succeeded: holds the live connection.

Everything connection-bound hangs off this value: subscriptions (Subscribe, subscribe), publishers (publisher), and requesters (requester). ConnectedBroker::shutdown consumes it, so a publish or subscribe after shutdown is a compile error for the owner of the handle.

Implementations

impl ConnectedLapinBroker

pub fn server_spec(&self) -> ServerSpec

The AsyncAPI server description of the connection this broker dialled.

pub async fn subscribe( &self, def: RabbitQueue, ) -> Result<LapinSubscriber, AmqpError>

Opens a subscription for def, declaring its topology first when the broker opted in.

Errors

Returns AmqpError::Closed after shutdown, AmqpError::Declare when opted-in declaration fails, AmqpError::InvalidOptions for contradictory descriptor options, and AmqpError::Subscribe when the channel or consumer cannot be opened (for example the queue does not exist and declaration was not opted into).

pub fn publisher<P: LapinPublishPolicy>(&self, policy: P) -> P::Live

A live publisher for policy.

LapinPublish pairs into the fire-and-forget publisher, ConfirmsPublish into the confirm-transactional one, and ServerTxPublish into the AMQP-server-transactional one. All three are cheap to build and cheap to clone.

Examples

use ruststream::Broker;
use ruststream_lapin::{LapinBroker, LapinPublish};

let connected = LapinBroker::new("amqp://localhost:5672").connect().await?;
let orders = connected.publisher(LapinPublish::default().exchange("orders"));
let shipments = connected.publisher(LapinPublish::default().confirms());

pub fn requester(&self, policy: LapinRequest) -> LapinRequester

A live request/reply client over RabbitMQ direct reply-to.

The requester half of LapinRequest; publisher accepts the same policy, this accessor only names the result.

Trait Implementations

impl ConnectedBroker for ConnectedLapinBroker

async fn shutdown(self) -> Result<Self::Closed, Self::Error>

Closes the connection, consuming the connected form.

Errors

Returns AmqpError::Connect when the close handshake fails.

type Error = AmqpError

The error type returned by connected-broker operations.

type Closed = ClosedLapinBroker

The terminal witness returned by shutdown.

impl Debug for ConnectedLapinBroker

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

Formats the value using the given formatter.

impl DefaultPublish for ConnectedLapinBroker

type Policy = LapinPublish

The broker’s plain publish policy, constructible with its defaults.

impl PublishPolicy<ConnectedLapinBroker> for LapinPublish

type Live = LapinPublisher

The live form this policy pairs into: a Publisher for a leaf policy, or the live wiring form for a combinator stack (a typed publisher over a policy pairs into the same typed publisher over the live leaf).

async fn pair( self, connected: &ConnectedLapinBroker, ) -> Result<Self::Live, PairError>

Pairs the policy with a connected broker, producing the live publisher.

impl PublishPolicy<ConnectedLapinBroker> for ConfirmsPublish

type Live = ConfirmsPublisher

The live form this policy pairs into: a Publisher for a leaf policy, or the live wiring form for a combinator stack (a typed publisher over a policy pairs into the same typed publisher over the live leaf).

async fn pair( self, connected: &ConnectedLapinBroker, ) -> Result<Self::Live, PairError>

Pairs the policy with a connected broker, producing the live publisher.

impl PublishPolicy<ConnectedLapinBroker> for ServerTxPublish

type Live = ServerTxPublisher

The live form this policy pairs into: a Publisher for a leaf policy, or the live wiring form for a combinator stack (a typed publisher over a policy pairs into the same typed publisher over the live leaf).

async fn pair( self, connected: &ConnectedLapinBroker, ) -> Result<Self::Live, PairError>

Pairs the policy with a connected broker, producing the live publisher.

impl PublishPolicy<ConnectedLapinBroker> for LapinRequest

type Live = LapinRequester

The live form this policy pairs into: a Publisher for a leaf policy, or the live wiring form for a combinator stack (a typed publisher over a policy pairs into the same typed publisher over the live leaf).

async fn pair( self, connected: &ConnectedLapinBroker, ) -> Result<Self::Live, PairError>

Pairs the policy with a connected broker, producing the live publisher.

impl Subscribe for ConnectedLapinBroker

async fn subscribe(&self, name: &str) -> Result<Self::Subscriber, Self::Error>

Subscribes to the queue name with descriptor defaults (durable, shared).

type Subscriber = LapinSubscriber

The subscriber type opened by a by-name subscription.

impl SubscriptionSource<ConnectedLapinBroker> for RabbitQueue

type Subscriber = LapinSubscriber

The subscriber type this source opens.

fn name(&self) -> &str

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

async fn subscribe( self, connected: &ConnectedLapinBroker, ) -> Result<Self::Subscriber, AmqpError>

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