use async_trait::async_trait;
use chrono::{DateTime, Utc};
use log::debug;
use std::sync::Arc;
use thiserror::Error;
#[derive(Error, Debug)]
pub enum MessageQueueError {
#[error("Database error: {0}")]
Database(String),
#[error("Queue not found: {0}")]
QueueNotFound(String),
#[error("Message not found: msg_id={0}")]
MessageNotFound(i64),
#[error("Serialization error: {0}")]
Serialization(#[from] serde_json::Error),
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct Message {
pub msg_id: i64,
pub queue_name: String,
pub message: serde_json::Value,
pub read_ct: i32,
pub enqueued_at: DateTime<Utc>,
}
#[async_trait]
pub trait MessageQueueRepository: Send + Sync {
async fn send(
&self,
queue_name: &str,
message: &serde_json::Value,
) -> Result<i64, MessageQueueError>;
async fn send_batch(
&self,
queue_name: &str,
messages: &[serde_json::Value],
) -> Result<Vec<i64>, MessageQueueError>;
async fn read_batch(
&self,
queue_name: &str,
vt: i32,
batch_size: i32,
) -> Result<Vec<Message>, MessageQueueError>;
async fn delete(&self, queue_name: &str, msg_id: i64) -> Result<bool, MessageQueueError>;
async fn delete_batch(
&self,
queue_name: &str,
msg_ids: &[i64],
) -> Result<u64, MessageQueueError>;
async fn archive(&self, queue_name: &str, msg_id: i64) -> Result<bool, MessageQueueError>;
async fn archive_batch(
&self,
queue_name: &str,
msg_ids: &[i64],
) -> Result<u64, MessageQueueError>;
}
#[async_trait]
pub trait MessageQueue: Send + Sync {
async fn send(
&self,
queue_name: &str,
message: &serde_json::Value,
) -> Result<i64, MessageQueueError>;
async fn send_batch(
&self,
queue_name: &str,
messages: &[serde_json::Value],
) -> Result<Vec<i64>, MessageQueueError>;
async fn read(&self, queue_name: &str, vt: i32) -> Result<Option<Message>, MessageQueueError>;
async fn read_batch(
&self,
queue_name: &str,
vt: i32,
batch_size: i32,
) -> Result<Vec<Message>, MessageQueueError>;
async fn delete(&self, queue_name: &str, msg_id: i64) -> Result<bool, MessageQueueError>;
async fn delete_batch(
&self,
queue_name: &str,
msg_ids: &[i64],
) -> Result<u64, MessageQueueError>;
async fn archive(&self, queue_name: &str, msg_id: i64) -> Result<bool, MessageQueueError>;
async fn archive_batch(
&self,
queue_name: &str,
msg_ids: &[i64],
) -> Result<u64, MessageQueueError>;
}
pub struct DbMessageQueue {
repo: Arc<dyn MessageQueueRepository>,
}
impl DbMessageQueue {
pub fn new(repo: Arc<dyn MessageQueueRepository>) -> Self {
Self { repo }
}
}
#[async_trait]
impl MessageQueue for DbMessageQueue {
async fn send(
&self,
queue_name: &str,
message: &serde_json::Value,
) -> Result<i64, MessageQueueError> {
let msg_id = self.repo.send(queue_name, message).await?;
debug!(
"message_queue: sent msg_id={} to queue={}",
msg_id, queue_name
);
Ok(msg_id)
}
async fn send_batch(
&self,
queue_name: &str,
messages: &[serde_json::Value],
) -> Result<Vec<i64>, MessageQueueError> {
let ids = self.repo.send_batch(queue_name, messages).await?;
debug!(
"message_queue: sent {} messages to queue={}",
ids.len(),
queue_name
);
Ok(ids)
}
async fn read(&self, queue_name: &str, vt: i32) -> Result<Option<Message>, MessageQueueError> {
let messages = self.read_batch(queue_name, vt, 1).await?;
Ok(messages.into_iter().next())
}
async fn read_batch(
&self,
queue_name: &str,
vt: i32,
batch_size: i32,
) -> Result<Vec<Message>, MessageQueueError> {
let messages = self.repo.read_batch(queue_name, vt, batch_size).await?;
if !messages.is_empty() {
debug!(
"message_queue: read {} messages from queue={}",
messages.len(),
queue_name
);
}
Ok(messages)
}
async fn delete(&self, queue_name: &str, msg_id: i64) -> Result<bool, MessageQueueError> {
let deleted = self.repo.delete(queue_name, msg_id).await?;
if deleted {
debug!(
"message_queue: deleted msg_id={} from queue={}",
msg_id, queue_name
);
}
Ok(deleted)
}
async fn delete_batch(
&self,
queue_name: &str,
msg_ids: &[i64],
) -> Result<u64, MessageQueueError> {
let count = self.repo.delete_batch(queue_name, msg_ids).await?;
if count > 0 {
debug!(
"message_queue: deleted {} messages from queue={}",
count, queue_name
);
}
Ok(count)
}
async fn archive(&self, queue_name: &str, msg_id: i64) -> Result<bool, MessageQueueError> {
let archived = self.repo.archive(queue_name, msg_id).await?;
if archived {
debug!(
"message_queue: archived msg_id={} from queue={}",
msg_id, queue_name
);
}
Ok(archived)
}
async fn archive_batch(
&self,
queue_name: &str,
msg_ids: &[i64],
) -> Result<u64, MessageQueueError> {
let count = self.repo.archive_batch(queue_name, msg_ids).await?;
if count > 0 {
debug!(
"message_queue: archived {} messages from queue={}",
count, queue_name
);
}
Ok(count)
}
}
#[async_trait]
impl<T: MessageQueue + ?Sized> MessageQueue for Arc<T> {
async fn send(
&self,
queue_name: &str,
message: &serde_json::Value,
) -> Result<i64, MessageQueueError> {
(**self).send(queue_name, message).await
}
async fn send_batch(
&self,
queue_name: &str,
messages: &[serde_json::Value],
) -> Result<Vec<i64>, MessageQueueError> {
(**self).send_batch(queue_name, messages).await
}
async fn read(&self, queue_name: &str, vt: i32) -> Result<Option<Message>, MessageQueueError> {
(**self).read(queue_name, vt).await
}
async fn read_batch(
&self,
queue_name: &str,
vt: i32,
batch_size: i32,
) -> Result<Vec<Message>, MessageQueueError> {
(**self).read_batch(queue_name, vt, batch_size).await
}
async fn delete(&self, queue_name: &str, msg_id: i64) -> Result<bool, MessageQueueError> {
(**self).delete(queue_name, msg_id).await
}
async fn delete_batch(
&self,
queue_name: &str,
msg_ids: &[i64],
) -> Result<u64, MessageQueueError> {
(**self).delete_batch(queue_name, msg_ids).await
}
async fn archive(&self, queue_name: &str, msg_id: i64) -> Result<bool, MessageQueueError> {
(**self).archive(queue_name, msg_id).await
}
async fn archive_batch(
&self,
queue_name: &str,
msg_ids: &[i64],
) -> Result<u64, MessageQueueError> {
(**self).archive_batch(queue_name, msg_ids).await
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::atomic::{AtomicI64, AtomicU64, Ordering};
struct MockRepository {
send_calls: AtomicU64,
read_calls: AtomicU64,
delete_calls: AtomicU64,
archive_calls: AtomicU64,
next_msg_id: AtomicI64,
}
impl MockRepository {
fn new() -> Self {
Self {
send_calls: AtomicU64::new(0),
read_calls: AtomicU64::new(0),
delete_calls: AtomicU64::new(0),
archive_calls: AtomicU64::new(0),
next_msg_id: AtomicI64::new(1),
}
}
}
#[async_trait]
impl MessageQueueRepository for MockRepository {
async fn send(
&self,
_queue_name: &str,
_message: &serde_json::Value,
) -> Result<i64, MessageQueueError> {
self.send_calls.fetch_add(1, Ordering::SeqCst);
Ok(self.next_msg_id.fetch_add(1, Ordering::SeqCst))
}
async fn send_batch(
&self,
queue_name: &str,
messages: &[serde_json::Value],
) -> Result<Vec<i64>, MessageQueueError> {
let mut ids = Vec::with_capacity(messages.len());
for msg in messages {
ids.push(self.send(queue_name, msg).await?);
}
Ok(ids)
}
async fn read_batch(
&self,
_queue_name: &str,
_vt: i32,
_batch_size: i32,
) -> Result<Vec<Message>, MessageQueueError> {
self.read_calls.fetch_add(1, Ordering::SeqCst);
Ok(vec![])
}
async fn delete(&self, _queue_name: &str, _msg_id: i64) -> Result<bool, MessageQueueError> {
self.delete_calls.fetch_add(1, Ordering::SeqCst);
Ok(true)
}
async fn delete_batch(
&self,
_queue_name: &str,
msg_ids: &[i64],
) -> Result<u64, MessageQueueError> {
self.delete_calls.fetch_add(1, Ordering::SeqCst);
Ok(msg_ids.len() as u64)
}
async fn archive(
&self,
_queue_name: &str,
_msg_id: i64,
) -> Result<bool, MessageQueueError> {
self.archive_calls.fetch_add(1, Ordering::SeqCst);
Ok(true)
}
async fn archive_batch(
&self,
_queue_name: &str,
msg_ids: &[i64],
) -> Result<u64, MessageQueueError> {
self.archive_calls.fetch_add(1, Ordering::SeqCst);
Ok(msg_ids.len() as u64)
}
}
#[test]
fn test_message_serialization() {
let msg = Message {
msg_id: 42,
queue_name: "test_queue".to_string(),
message: serde_json::json!({"key": "value"}),
read_ct: 3,
enqueued_at: Utc::now(),
};
let json = serde_json::to_string(&msg).expect("serialize should succeed");
let deserialized: Message =
serde_json::from_str(&json).expect("deserialize should succeed");
assert_eq!(deserialized.msg_id, 42);
assert_eq!(deserialized.queue_name, "test_queue");
assert_eq!(deserialized.read_ct, 3);
assert_eq!(deserialized.message, serde_json::json!({"key": "value"}));
}
#[test]
fn test_error_display() {
let err = MessageQueueError::QueueNotFound("my_queue".to_string());
assert_eq!(err.to_string(), "Queue not found: my_queue");
let err = MessageQueueError::MessageNotFound(123);
assert_eq!(err.to_string(), "Message not found: msg_id=123");
let err = MessageQueueError::Database("connection lost".to_string());
assert_eq!(err.to_string(), "Database error: connection lost");
}
#[tokio::test]
async fn test_send_increments_counter() {
let repo = Arc::new(MockRepository::new());
let queue = DbMessageQueue::new(repo.clone());
let msg_id = queue
.send("test", &serde_json::json!({"data": 1}))
.await
.unwrap();
assert_eq!(msg_id, 1);
assert_eq!(repo.send_calls.load(Ordering::SeqCst), 1);
let msg_id2 = queue
.send("test", &serde_json::json!({"data": 2}))
.await
.unwrap();
assert_eq!(msg_id2, 2);
assert_eq!(repo.send_calls.load(Ordering::SeqCst), 2);
}
#[tokio::test]
async fn test_send_batch() {
let repo = Arc::new(MockRepository::new());
let queue = DbMessageQueue::new(repo.clone());
let messages = vec![
serde_json::json!({"a": 1}),
serde_json::json!({"b": 2}),
serde_json::json!({"c": 3}),
];
let ids = queue.send_batch("test", &messages).await.unwrap();
assert_eq!(ids.len(), 3);
assert_eq!(ids, vec![1, 2, 3]);
assert_eq!(repo.send_calls.load(Ordering::SeqCst), 3);
}
#[tokio::test]
async fn test_read_returns_none_on_empty() {
let repo = Arc::new(MockRepository::new());
let queue = DbMessageQueue::new(repo.clone());
let result = queue.read("test", 30).await.unwrap();
assert!(result.is_none());
assert_eq!(repo.read_calls.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_read_batch_returns_empty() {
let repo = Arc::new(MockRepository::new());
let queue = DbMessageQueue::new(repo.clone());
let result = queue.read_batch("test", 30, 5).await.unwrap();
assert!(result.is_empty());
assert_eq!(repo.read_calls.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_delete_returns_true() {
let repo = Arc::new(MockRepository::new());
let queue = DbMessageQueue::new(repo.clone());
let result = queue.delete("test", 1).await.unwrap();
assert!(result);
assert_eq!(repo.delete_calls.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_delete_batch() {
let repo = Arc::new(MockRepository::new());
let queue = DbMessageQueue::new(repo.clone());
let count = queue.delete_batch("test", &[1, 2, 3]).await.unwrap();
assert_eq!(count, 3);
assert_eq!(repo.delete_calls.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_archive_returns_true() {
let repo = Arc::new(MockRepository::new());
let queue = DbMessageQueue::new(repo.clone());
let result = queue.archive("test", 1).await.unwrap();
assert!(result);
assert_eq!(repo.archive_calls.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_archive_batch() {
let repo = Arc::new(MockRepository::new());
let queue = DbMessageQueue::new(repo.clone());
let count = queue.archive_batch("test", &[1, 2]).await.unwrap();
assert_eq!(count, 2);
assert_eq!(repo.archive_calls.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_arc_delegation_send() {
let repo = Arc::new(MockRepository::new());
let queue = Arc::new(DbMessageQueue::new(repo.clone()));
let queue: Arc<dyn MessageQueue> = queue;
let msg_id = queue
.send("test", &serde_json::json!({"x": 1}))
.await
.unwrap();
assert_eq!(msg_id, 1);
assert_eq!(repo.send_calls.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_arc_delegation_read() {
let repo = Arc::new(MockRepository::new());
let queue = Arc::new(DbMessageQueue::new(repo.clone()));
let queue: Arc<dyn MessageQueue> = queue;
let result = queue.read("test", 30).await.unwrap();
assert!(result.is_none());
assert_eq!(repo.read_calls.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_arc_delegation_delete() {
let repo = Arc::new(MockRepository::new());
let queue = Arc::new(DbMessageQueue::new(repo.clone()));
let queue: Arc<dyn MessageQueue> = queue;
let result = queue.delete("test", 1).await.unwrap();
assert!(result);
assert_eq!(repo.delete_calls.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_arc_delegation_archive() {
let repo = Arc::new(MockRepository::new());
let queue = Arc::new(DbMessageQueue::new(repo.clone()));
let queue: Arc<dyn MessageQueue> = queue;
let result = queue.archive("test", 1).await.unwrap();
assert!(result);
assert_eq!(repo.archive_calls.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_arc_delegation_send_batch() {
let repo = Arc::new(MockRepository::new());
let queue = Arc::new(DbMessageQueue::new(repo.clone()));
let queue: Arc<dyn MessageQueue> = queue;
let ids = queue
.send_batch("test", &[serde_json::json!({"a": 1})])
.await
.unwrap();
assert_eq!(ids.len(), 1);
assert_eq!(repo.send_calls.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_arc_delegation_read_batch() {
let repo = Arc::new(MockRepository::new());
let queue = Arc::new(DbMessageQueue::new(repo.clone()));
let queue: Arc<dyn MessageQueue> = queue;
let msgs = queue.read_batch("test", 30, 5).await.unwrap();
assert!(msgs.is_empty());
assert_eq!(repo.read_calls.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_arc_delegation_delete_batch() {
let repo = Arc::new(MockRepository::new());
let queue = Arc::new(DbMessageQueue::new(repo.clone()));
let queue: Arc<dyn MessageQueue> = queue;
let count = queue.delete_batch("test", &[1, 2]).await.unwrap();
assert_eq!(count, 2);
}
#[tokio::test]
async fn test_arc_delegation_archive_batch() {
let repo = Arc::new(MockRepository::new());
let queue = Arc::new(DbMessageQueue::new(repo.clone()));
let queue: Arc<dyn MessageQueue> = queue;
let count = queue.archive_batch("test", &[1]).await.unwrap();
assert_eq!(count, 1);
}
}