rabbitmq_service 0.1.1

A library to accelerate RabbitMQ deployment and management.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

# RabbitMQ Service

A library to accelerate RabbitMQ deployment and management in Rust applications. This library provides a simple API for interacting with RabbitMQ, including queue creation, message publishing, and receiving responses.

## Features

- Connect to RabbitMQ using a specified URI.
- Declare two queues: `<queue_name>_requests` and `<queue_name>_responses`.
- Publish messages to the `_requests` queue.
- Receive responses from the `_responses` queue.
- Message serialization and deserialization with `serde`.
- Automatic message acknowledgment.

## Installation

To include this crate in your project, add it to your `Cargo.toml`:

```toml
[dependencies]
rabbitmq_service = { git = "https://github.com/SentineLLM-1/rabbitmq_service" }
```

## Usage

Below is a basic example of how to use the `RabbitMQService` in your application.

### Example

```rust
use rabbitmq_service::RabbitMQService;
use tokio;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a new RabbitMQ service connected to your RabbitMQ server
    let service = RabbitMQService::new("amqp://localhost", "my_queue").await?;

    // Send a message to the requests queue
    service.send_message("my_queue", "Hello, RabbitMQ!".into()).await?;

    // Wait for a response from the responses queue
    let response = service.receive_response("my_queue".into()).await?;

    println!("Received response: {}", response);

    Ok(())
}
```

### API

#### `new(uri: &str, queue_name: &str) -> Result<Self, Error>`

Constructs a new `RabbitMQService` instance connected to the specified RabbitMQ URI and initializes the two required queues: `<queue_name>_requests` and `<queue_name>_responses`.

- **Arguments**:
  - `uri`: The URI of the RabbitMQ server.
  - `queue_name`: The base name for the request/response queues.
  
- **Returns**: A `Result` with `RabbitMQService` or an `Error` if the connection or queue declaration fails.

#### `send_message(&self, queue_name: &str, message: String) -> Result<(), Error>`

Sends a serialized message to the specified `_requests` queue.

- **Arguments**:
  - `queue_name`: The base name of the queue (will append `_requests`).
  - `message`: The message content to send.

- **Returns**: A `Result` indicating whether the message was successfully sent.

#### `receive_response(&self, queue_name: String) -> Result<String, Error>`

Receives a response from the specified `_responses` queue.

- **Arguments**:
  - `queue_name`: The base name of the queue (will append `_responses`).
  
- **Returns**: A `Result` containing the received response as a `String`, or an error if the response cannot be received or processed.

## Error Handling

The library uses the `Error` type to handle various issues that may arise, such as connection errors, queue declaration errors, or message processing errors. Errors include but are not limited to:

- **Connection failures**.
- **Queue declaration failures**.
- **Message serialization/deserialization errors**.
- **Timeouts or missing messages in the response queue**.

## Dependencies

- `rabbit_mqr` for RabbitMQ management.
- `serde` and `serde_json` for message serialization and deserialization.
- `uuid` for generating unique message IDs.
- `tokio` for asynchronous runtime.

## License

This project is licensed under the Apache-2.0 License.

## Contributing

Contributions are welcome! Please feel free to fork the repository, make changes, and submit pull requests.

## Author

- **Femure** <maxime.femery@gmail.com>

---

Feel free to modify or expand upon the README as needed!