AMQP Client Rust

A Rust client library for interacting with RabbitMQ using AMQP. This library provides high-level abstractions for working with RabbitMQ, including automatic queue and exchange management, message publishing, subscribing, and RPC support.

Features:

• Asynchronous API with Tokio;
• Automatic queue and exchange management;
• RPC (Remote Procedure Call) functionality;
• Reconnection and error handling;

Getting Started

Installation

Add the following to your Cargo.toml:

[dependencies]
amqp-client-rust = "0.0.3-alpha.2"
amqprs = "1.5"
async-trait = "0.1"
tokio = { version = "1", features = ["rt", "rt-multi-thread", "sync", "net", "io-util", "time", "macros"] }
uuid = { version = "1.3.3", features = ["v4"] }
url = "2.2.2"

Example Usage

Here is an example demonstrating how to use amqp-client-rust to publish and subscribe to messages, as well as handle RPC calls:

use std::error::Error as StdError;
use tokio::time::{sleep, Duration};
use amqp_client_rust::{
    api::eventbus::AsyncEventbusRabbitMQ,
    domain::{
        config::{Config, ConfigOptions},
        integration_event::IntegrationEvent,
    },
    errors::AppError
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = Config::from_url(
        "amqp://guest:guest@localhost:5672",
        ConfigOptions {
            queue_name: "example_queue".to_string(),
            rpc_queue_name: "rpc_queue".to_string(),
            rpc_exchange_name: "rpc_exchange".to_string(),
        },
    )?;

    let eventbus = AsyncEventbusRabbitMQ::new(config).await;
    let example_event = IntegrationEvent::new("teste.iso", "example.exchange");
    async fn handle(_body: Vec<u8>) -> Result<(), Box<dyn StdError + Send + Sync>> {
        Ok(())
    }

    eventbus
        .subscribe(
            &example_event.event_type(),
            handle,
            &example_event.routing_key,
            "application/json",
            None,
        )
        .await?;

    let content = String::from(
        r#"
            {
                "data": "Hello, amqprs!"
            }
        "#,
    )
    .into_bytes();

    async fn rpc_handler(_body: Vec<u8>) -> Result<Vec<u8>, Box<dyn StdError + Send + Sync>> {
        Ok("Ok".into())
    }
    eventbus
        .rpc_server(rpc_handler, &example_event.routing_key, "application/json", None)
        .await;
    let timeout = 1000;
    for _ in 0..30 {
        for _ in 0..2000 {
            async fn process(body: Result<Vec<u8>, AppError>) -> Result<(), Box<(dyn std::error::Error + Send + Sync + 'static)>>{
                if body.is_err(){
                    println!("Error: {:?}", body.err().unwrap());
                } else {
                    println!("Response: {:?}", String::from_utf8(body.unwrap()).unwrap());
                }
                Ok(())
            }
            eventbus
                .publish(
                    &example_event.event_type(),
                    &example_event.routing_key,
                    content.clone(),
                    Some("application/json"),
                    None
                )
                .await?;
            let _ = eventbus
                .rpc_client(
                    "rpc_exchange",
                    &example_event.routing_key,
                    content.clone(),
                    process,
                    
                    "application/json",
                    timeout,
                    None,
                    Some(timeout)
    
                )
                .await;
        }
        sleep(Duration::from_secs(1)).await;
    }
    println!("end");

    Ok(())
}

Contributing

Contributions are welcome! Please open issues or pull requests on GitHub.

License

This project is licensed under the Apache 2.0 License.

Acknowledgments

This library was inspired by the amqp-client-python library, which provides a similar abstraction for RabbitMQ in Python. The design and functionality of amqp-client-python greatly influenced the development of this Rust library.

amqp-client-python: GitHub Repository | PyPI Page