things

amqp_messaging/src/methods/consume.rs

@@ -1,13 +1,15 @@
 use crate::Result;
-use amqp_core::amqp_todo;
-use amqp_core::connection::ChannelHandle;
-use amqp_core::consumer::{Consumer, ConsumerId};
-use amqp_core::error::{ChannelException};
-use amqp_core::methods::{BasicConsume, BasicConsumeOk, Method};
+use amqp_core::{
+    amqp_todo,
+    connection::Channel,
+    consumer::{Consumer, ConsumerId},
+    error::ChannelException,
+    methods::{BasicConsume, BasicConsumeOk, Method},
+};
 use std::sync::Arc;
 use tracing::info;
 
-pub fn consume(channel_handle: ChannelHandle, basic_consume: BasicConsume) -> Result<Method> {
+pub fn consume(channel_handle: Channel, basic_consume: BasicConsume) -> Result<Method> {
     let BasicConsume {
         queue: queue_name,
         consumer_tag,

amqp_messaging/src/methods/mod.rs

@@ -3,20 +3,18 @@ mod publish;
 mod queue;
 
 use crate::Result;
-use amqp_core::amqp_todo;
-use amqp_core::connection::ChannelHandle;
-use amqp_core::message::Message;
-use amqp_core::methods::Method;
+use amqp_core::{amqp_todo, connection::Channel, message::Message, methods::Method};
+use std::sync::Arc;
 use tracing::{error, info};
 
-pub async fn handle_basic_publish(channel_handle: ChannelHandle, message: Message) {
+pub async fn handle_basic_publish(channel_handle: Arc<Channel>, message: Message) {
     match publish::publish(channel_handle, message).await {
         Ok(()) => {}
         Err(err) => error!(%err, "publish error occurred"),
     }
 }
 
-pub async fn handle_method(channel_handle: ChannelHandle, method: Method) -> Result<Method> {
+pub async fn handle_method(channel_handle: Arc<Channel>, method: Method) -> Result<Method> {
     info!(?method, "Handling method");
 
     let response = match method {

amqp_messaging/src/methods/publish.rs

@@ -1,12 +1,14 @@
 use crate::Result;
-use amqp_core::amqp_todo;
-use amqp_core::connection::{ChannelHandle, QueuedMethod};
-use amqp_core::error::ChannelException;
-use amqp_core::message::Message;
-use amqp_core::methods::{BasicPublish, Method};
+use amqp_core::{
+    amqp_todo,
+    connection::{Channel, QueuedMethod},
+    error::ChannelException,
+    message::Message,
+    methods::{BasicPublish, Method},
+};
 use tracing::info;
 
-pub async fn publish(channel_handle: ChannelHandle, message: Message) -> Result<()> {
+pub async fn publish(channel_handle: Arc<Channel>, message: Message) -> Result<()> {
     info!(?message, "Publishing message");
 
     let global_data = channel_handle.lock().global_data.clone();

amqp_messaging/src/methods/queue.rs

@@ -1,16 +1,15 @@
-use amqp_core::connection::ChannelHandle;
-use amqp_core::methods::{Method, QueueBind, QueueDeclare, QueueDeclareOk};
-use amqp_core::queue::{QueueDeletion, QueueId, QueueName, RawQueue};
-use amqp_core::{amqp_todo, GlobalData};
-use parking_lot::Mutex;
-use std::sync::atomic::AtomicUsize;
-use std::sync::Arc;
 use crate::Result;
+use amqp_core::{
+    amqp_todo,
+    connection::Channel,
+    methods::{Method, QueueBind, QueueDeclare, QueueDeclareOk},
+    queue::{QueueDeletion, QueueId, QueueName, RawQueue},
+    GlobalData,
+};
+use parking_lot::Mutex;
+use std::sync::{atomic::AtomicUsize, Arc};
 
-pub fn declare(
-    channel_handle: ChannelHandle,
-    queue_declare: QueueDeclare,
-) -> Result<Method> {
+pub fn declare(channel_handle: Channel, queue_declare: QueueDeclare) -> Result<Method> {
     let QueueDeclare {
         queue: queue_name,
         passive,
@@ -70,18 +69,11 @@ pub fn declare(
     }))
 }
 
-pub async fn bind(
-    _channel_handle: ChannelHandle,
-    _queue_bind: QueueBind,
-) -> Result<Method> {
+pub async fn bind(_channel_handle: Channel, _queue_bind: QueueBind) -> Result<Method> {
     amqp_todo!();
 }
 
-fn bind_queue(
-    global_data: GlobalData,
-    _exchange: (),
-    routing_key: Arc<str>,
-) -> Result<()> {
+fn bind_queue(global_data: GlobalData, _exchange: (), routing_key: Arc<str>) -> Result<()> {
     let mut global_data = global_data.lock();
 
     // todo: don't