improved rabbitmq structs

src/rabbitmq/mod.rs

@@ -1,36 +1,170 @@
-use lapin::{
-    options::*, types::FieldTable, BasicProperties, Channel, Connection, ConnectionProperties, Result
-};
+// use lapin::{
+//     options::*, types::FieldTable, BasicProperties, Channel, Connection, ConnectionProperties, Result
+// };
 
-pub struct RabbitMQClient {
+// pub struct RabbitMQClient {
+//     pub connection: Connection,
+//     pub channel: Channel,
+// }
+
+// impl RabbitMQClient {
+//     pub async fn new(addr: &str) -> Result<Self> {
+//         let connection = Connection::connect(addr, ConnectionProperties::default()).await?;
+//         let channel = connection.create_channel().await?;
+
+//         Ok(Self { connection, channel })
+//     }
+
+//     pub async fn publish(&self, queue: &str, payload: &[u8]) -> Result<()> {
+//         self.channel
+//             .basic_publish(
+//                 "",
+//                 queue,
+//                 Default::default(),
+//                 payload,
+//                 BasicProperties::default(),
+//             )
+//             .await?;
+
+//         Ok(())
+//     }
+
+//     pub async fn consume(&self, queue: &str) -> Result<lapin::Consumer> {
+//         let consumer = self.channel
+//             .basic_consume(
+//                 queue,
+//                 "consumer",
+//                 BasicConsumeOptions::default(),
+//                 FieldTable::default(),
+//             )
+//             .await?;
+
+//         Ok(consumer)
+//     }
+// }
+use lapin::{
+    options::*, types::FieldTable, BasicProperties, Channel, Connection, ConnectionProperties, Consumer, ExchangeKind 
+};
+use futures_lite::stream::StreamExt;
+
+#[derive(Debug, thiserror::Error)]
+pub enum RabbitMQError {
+    #[error("Connection error: {0}")]
+    ConnectionError(#[from] lapin::Error),
+    #[error("Channel error: {0}")]
+    ChannelError(String),
+    #[error("Consume error: {0}")]
+    ConsumeError(String),
+    #[error("Publish error: {0}")]
+    PublishError(String),
+}
+
+struct RabbitMQConnection {
     pub connection: Connection,
     pub channel: Channel,
 }
 
-impl RabbitMQClient {
-    pub async fn new(addr: &str) -> Result<Self> {
-        let connection = Connection::connect(addr, ConnectionProperties::default()).await?;
+impl RabbitMQConnection {
+    async fn new(url: &str) -> Result<Self, RabbitMQError> {
+        let connection = Connection::connect(
+            url,
+            ConnectionProperties::default(),
+        ).await?;
+        
         let channel = connection.create_channel().await?;
-
+        
         Ok(Self { connection, channel })
     }
+}
 
-    pub async fn publish(&self, queue: &str, payload: &[u8]) -> Result<()> {
-        self.channel
-            .basic_publish(
-                "",
-                queue,
-                Default::default(),
-                payload,
-                BasicProperties::default(),
-            )
-            .await?;
+// pub struct RabbitMQConsumer {
+//     connection: RabbitMQConnection,
+//     queue_name: String,
+// }
 
-        Ok(())
-    }
+// impl RabbitMQConsumer {
+//     pub async fn new(url: &str, queue_name: &str) -> Result<Self, RabbitMQError> {
+//         let connection = RabbitMQConnection::new(url).await?;
+//         Ok(Self {
+//             connection,
+//             queue_name: queue_name.to_string(),
+//         })
+//     }
 
-    pub async fn consume(&self, queue: &str) -> Result<lapin::Consumer> {
-        let consumer = self.channel
+//     pub async fn consume(&self) -> Result<String, RabbitMQError> {
+//         let consumer = self.connection.channel
+//             .basic_consume(
+//                 &self.queue_name,
+//                 "consumer",
+//                 BasicConsumeOptions::default(),
+//                 FieldTable::default(),
+//             )
+//             .await
+//             .map_err(|e| RabbitMQError::ConsumeError(e.to_string()))?;
+
+//         let delivery = consumer.clone().next().await
+//             .ok_or_else(|| RabbitMQError::ConsumeError("No message received".to_string()))?
+//             .map_err(|e| RabbitMQError::ConsumeError(e.to_string()))?;
+
+//         let message = String::from_utf8_lossy(&delivery.data).to_string();
+
+//         self.connection.channel
+//             .basic_ack(delivery.delivery_tag, BasicAckOptions::default())
+//             .await
+//             .map_err(|e| RabbitMQError::ConsumeError(e.to_string()))?;
+
+//         Ok(message)
+//     }
+// }
+pub struct RabbitMQConsumer {
+    connection: Connection,
+    channel: Channel,
+    consumer: Consumer,
+}
+
+impl RabbitMQConsumer {
+    pub async fn new(url: &str, exchange: &str, queue: &str, routing_key: &str) -> Result<Self, RabbitMQError> {
+        let connection = Connection::connect(
+            url,
+            ConnectionProperties::default(),
+        ).await?;
+        
+        let channel = connection.create_channel().await?;
+
+        // Declare the exchange
+        channel.exchange_declare(
+            exchange,
+            ExchangeKind::Topic,
+            ExchangeDeclareOptions {
+                durable: true,
+                auto_delete: false,
+                ..ExchangeDeclareOptions::default()
+            },
+            FieldTable::default(),
+        ).await?;
+
+        // Declare the queue
+        channel.queue_declare(
+            queue,
+            QueueDeclareOptions {
+                durable: true,
+                auto_delete: false,
+                ..QueueDeclareOptions::default()
+            },
+            FieldTable::default(),
+        ).await?;
+
+        // Bind the queue to the exchange
+        channel.queue_bind(
+            queue,
+            exchange,
+            routing_key,
+            QueueBindOptions::default(),
+            FieldTable::default(),
+        ).await?;
+
+        // Create the consumer
+        let consumer = channel
             .basic_consume(
                 queue,
                 "consumer",
@@ -39,6 +173,78 @@ impl RabbitMQClient {
             )
             .await?;
 
-        Ok(consumer)
+        Ok(Self {
+            connection,
+            channel,
+            consumer,
+        })
+    }
+
+    pub async fn consume(&self) -> Result<String, RabbitMQError> {
+        let delivery = self.consumer.clone().next().await
+            .ok_or_else(|| RabbitMQError::ConsumeError("No message received".to_string()))?
+            .map_err(|e| RabbitMQError::ConsumeError(e.to_string()))?;
+
+        let message = String::from_utf8_lossy(&delivery.data).to_string();
+
+        self.channel
+            .basic_ack(delivery.delivery_tag, BasicAckOptions::default())
+            .await
+            .map_err(|e| RabbitMQError::ConsumeError(e.to_string()))?;
+
+        Ok(message)
+    }
+}
+
+
+pub struct RabbitMQProducer {
+    connection: Connection,
+    channel: Channel,
+    exchange_name: String,
+    routing_key: String,
+}
+
+impl RabbitMQProducer {
+    pub async fn new(url: &str, exchange_name: &str, routing_key: &str) -> Result<Self, RabbitMQError> {
+        let connection = Connection::connect(
+            url,
+            ConnectionProperties::default(),
+        ).await?;
+        
+        let channel = connection.create_channel().await?;
+
+        // Declare the exchange
+        channel.exchange_declare(
+            exchange_name,
+            ExchangeKind::Topic,
+            ExchangeDeclareOptions {
+                durable: true,
+                auto_delete: false,
+                ..ExchangeDeclareOptions::default()
+            },
+            FieldTable::default(),
+        ).await?;
+
+        Ok(Self {
+            connection,
+            channel,
+            exchange_name: exchange_name.to_string(),
+            routing_key: routing_key.to_string(),
+        })
+    }
+
+    pub async fn publish(&self, message: &str) -> Result<(), RabbitMQError> {
+        self.channel
+            .basic_publish(
+                &self.exchange_name,
+                &self.routing_key,
+                BasicPublishOptions::default(),
+                message.as_bytes(),
+                BasicProperties::default(),
+            )
+            .await?
+            .await?;
+
+        Ok(())
     }
 }