Struct Publisher 

pub struct Publisher { /* private fields */ }

Simplified Publisher for message publishing

Implementations

impl Publisher

pub fn new(connection: Arc<Connection>) -> Self

Create a new publisher

pub async fn publish_to_exchange<T>( &self, exchange: &str, routing_key: &str, message: &T, options: Option<PublishOptions>, ) -> Result<(), RustRabbitError>

where T: Serialize,

Publish message to an exchange

pub async fn publish_to_queue<T>( &self, queue: &str, message: &T, options: Option<PublishOptions>, ) -> Result<(), RustRabbitError>

where T: Serialize,

Publish message directly to a queue

pub async fn publish_envelope_to_exchange<T>( &self, exchange: &str, routing_key: &str, envelope: &MessageEnvelope<T>, options: Option<PublishOptions>, ) -> Result<(), RustRabbitError>

where T: Serialize,

Publish a message envelope to an exchange (includes retry metadata)

pub async fn publish_envelope_to_queue<T>( &self, queue: &str, envelope: &MessageEnvelope<T>, options: Option<PublishOptions>, ) -> Result<(), RustRabbitError>

where T: Serialize,

Publish a message envelope directly to a queue (includes retry metadata)

pub async fn publish_with_envelope<T>( &self, exchange: &str, routing_key: &str, payload: &T, source_queue: &str, max_retries: u32, options: Option<PublishOptions>, ) -> Result<(), RustRabbitError>

where T: Serialize + Clone,

Create a message envelope with source tracking and publish to exchange

pub async fn publish_with_envelope_to_queue<T>( &self, queue: &str, payload: &T, max_retries: u32, options: Option<PublishOptions>, ) -> Result<(), RustRabbitError>

where T: Serialize + Clone,

Create a message envelope and publish directly to queue

pub async fn publish_masstransit_to_exchange<T>( &self, exchange: &str, routing_key: &str, message: &T, message_type: &str, options: Option<PublishOptions>, ) -> Result<(), RustRabbitError>

where T: Serialize,

Publish a message to MassTransit-compatible exchange This ensures the message format matches MassTransit’s expectations

Arguments

• exchange - Exchange name (MassTransit typically uses exchange names)
• routing_key - Routing key (often the message type name)
• message - The message payload to publish
• message_type - Message type name (e.g., “YourNamespace:YourMessageType”) - required for MassTransit routing
• options - Optional publish options

Example

use rust_rabbit::{Connection, Publisher};

#[derive(serde::Serialize)]
struct OrderCreated {
    order_id: u32,
    amount: f64,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let connection = Connection::new("amqp://localhost:5672").await?;
    let publisher = Publisher::new(connection);
     
    let order = OrderCreated { order_id: 123, amount: 99.99 };
    publisher.publish_masstransit_to_exchange(
        "order-exchange",
        "order.created",
        &order,
        "Contracts:OrderCreated", // Message type for MassTransit
        None
    ).await?;
     
    Ok(())
}

pub async fn publish_masstransit_to_queue<T>( &self, queue: &str, message: &T, message_type: &str, options: Option<PublishOptions>, ) -> Result<(), RustRabbitError>

where T: Serialize,

Publish a message to MassTransit-compatible queue This ensures the message format matches MassTransit’s expectations

Arguments

• queue - Queue name
• message - The message payload to publish
• message_type - Message type name (e.g., “YourNamespace:YourMessageType”) - required for MassTransit routing
• options - Optional publish options

Example

use rust_rabbit::{Connection, Publisher};

#[derive(serde::Serialize)]
struct OrderCreated {
    order_id: u32,
    amount: f64,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let connection = Connection::new("amqp://localhost:5672").await?;
    let publisher = Publisher::new(connection);
     
    let order = OrderCreated { order_id: 123, amount: 99.99 };
    publisher.publish_masstransit_to_queue(
        "order-queue",
        &order,
        "Contracts:OrderCreated", // Message type for MassTransit
        None
    ).await?;
     
    Ok(())
}

pub async fn publish_masstransit_envelope_to_exchange( &self, exchange: &str, routing_key: &str, envelope: &MassTransitEnvelope, options: Option<PublishOptions>, ) -> Result<(), RustRabbitError>

Publish a MassTransit envelope (already created) to an exchange Useful when you need full control over the envelope structure

pub async fn publish_masstransit_envelope_to_queue( &self, queue: &str, envelope: &MassTransitEnvelope, options: Option<PublishOptions>, ) -> Result<(), RustRabbitError>

Publish a MassTransit envelope (already created) to a queue Useful when you need full control over the envelope structure