use crate::common::metrics_shim::gauge;
use crate::domain::models::Task;
use crate::domain::repositories::task_repository::TaskRepository;
use async_trait::async_trait;
use log::debug;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::Arc;
use thiserror::Error;
#[derive(Error, Debug)]
pub enum QueueError {
#[error("Repository error: {0}")]
Repository(#[from] crate::domain::repositories::task_repository::RepositoryError),
#[error("Queue empty")]
Empty,
}
#[async_trait]
pub trait TaskQueue: Send + Sync {
async fn enqueue(&self, task: Task) -> Result<Task, QueueError>;
async fn dequeue(&self, worker_id: crate::domain::id::Id) -> Result<Option<Task>, QueueError>;
async fn complete(&self, task_id: crate::domain::id::Id) -> Result<(), QueueError>;
async fn fail(&self, task_id: crate::domain::id::Id) -> Result<(), QueueError>;
async fn cancel(&self, task_id: crate::domain::id::Id) -> Result<(), QueueError>;
}
pub struct PostgresTaskQueue {
pub repository: Arc<dyn TaskRepository>,
depth: AtomicU64,
}
impl PostgresTaskQueue {
pub fn new(repository: Arc<dyn TaskRepository>) -> Self {
Self {
repository,
depth: AtomicU64::new(0),
}
}
}
#[async_trait]
impl TaskQueue for PostgresTaskQueue {
async fn enqueue(&self, task: Task) -> Result<Task, QueueError> {
let created = self.repository.create(&task).await?;
let new_depth = self.depth.fetch_add(1, Ordering::Relaxed) + 1;
gauge!("crawlrs_queue_depth", "queue_type" => "task").set(new_depth as f64);
Ok(created)
}
async fn dequeue(&self, worker_id: crate::domain::id::Id) -> Result<Option<Task>, QueueError> {
debug!("worker_id={}", worker_id);
let task = self.repository.acquire_next(worker_id).await?;
if task.is_some() {
let mut observed = self.depth.load(Ordering::Relaxed);
loop {
let next = observed.saturating_sub(1);
match self.depth.compare_exchange_weak(
observed,
next,
Ordering::Relaxed,
Ordering::Relaxed,
) {
Ok(_) => break,
Err(now) => observed = now,
}
}
}
let current = self.depth.load(Ordering::Relaxed);
gauge!("crawlrs_queue_depth", "queue_type" => "task").set(current as f64);
debug!("has_task={:?}", task.is_some());
Ok(task)
}
async fn complete(&self, task_id: crate::domain::id::Id) -> Result<(), QueueError> {
self.repository.mark_completed(task_id, None).await?;
Ok(())
}
async fn fail(&self, task_id: crate::domain::id::Id) -> Result<(), QueueError> {
self.repository.mark_failed(task_id, None).await?;
Ok(())
}
async fn cancel(&self, task_id: crate::domain::id::Id) -> Result<(), QueueError> {
self.repository.mark_cancelled(task_id).await?;
Ok(())
}
}
#[async_trait]
impl<T: TaskQueue + ?Sized> TaskQueue for Arc<T> {
async fn enqueue(&self, task: Task) -> Result<Task, QueueError> {
(**self).enqueue(task).await
}
async fn dequeue(&self, worker_id: crate::domain::id::Id) -> Result<Option<Task>, QueueError> {
(**self).dequeue(worker_id).await
}
async fn complete(&self, task_id: crate::domain::id::Id) -> Result<(), QueueError> {
(**self).complete(task_id).await
}
async fn fail(&self, task_id: crate::domain::id::Id) -> Result<(), QueueError> {
(**self).fail(task_id).await
}
async fn cancel(&self, task_id: crate::domain::id::Id) -> Result<(), QueueError> {
(**self).cancel(task_id).await
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::domain::models::{Task, TaskType};
use crate::domain::repositories::task_repository::{
RepositoryError, TaskQueryParams, TaskRepository,
};
use async_trait::async_trait;
use chrono::Duration as ChronoDuration;
use std::collections::HashSet;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
struct MockTaskRepository {
enqueue_calls: AtomicUsize,
dequeue_calls: AtomicUsize,
complete_calls: AtomicUsize,
fail_calls: AtomicUsize,
cancel_calls: AtomicUsize,
last_task_id: parking_lot::Mutex<Option<crate::domain::id::Id>>,
last_worker_id: parking_lot::Mutex<Option<crate::domain::id::Id>>,
should_fail: bool,
next_task: parking_lot::Mutex<Option<Task>>,
created_task: parking_lot::Mutex<Option<Task>>,
}
impl MockTaskRepository {
fn new() -> Self {
Self {
enqueue_calls: AtomicUsize::new(0),
dequeue_calls: AtomicUsize::new(0),
complete_calls: AtomicUsize::new(0),
fail_calls: AtomicUsize::new(0),
cancel_calls: AtomicUsize::new(0),
last_task_id: parking_lot::Mutex::new(None),
last_worker_id: parking_lot::Mutex::new(None),
should_fail: false,
next_task: parking_lot::Mutex::new(None),
created_task: parking_lot::Mutex::new(None),
}
}
fn failing() -> Self {
let mut mock = Self::new();
mock.should_fail = true;
mock
}
fn with_next_task(task: Task) -> Self {
let mock = Self::new();
*mock.next_task.lock() = Some(task);
mock
}
}
fn sample_task() -> Task {
Task::new(
crate::domain::id::Id::generate(),
TaskType::Scrape,
crate::domain::id::Id::generate(),
crate::domain::id::Id::generate(),
"https://example.com".to_string(),
serde_json::json!({}),
)
}
fn db_error() -> RepositoryError {
RepositoryError::Database(anyhow::anyhow!("mock database failure"))
}
#[async_trait]
impl TaskRepository for MockTaskRepository {
async fn create(&self, task: &Task) -> Result<Task, RepositoryError> {
self.enqueue_calls.fetch_add(1, Ordering::SeqCst);
if self.should_fail {
return Err(db_error());
}
let created = self
.created_task
.lock()
.clone()
.unwrap_or_else(|| task.clone());
Ok(created)
}
async fn find_by_id(
&self,
_id: crate::domain::id::Id,
) -> Result<Option<Task>, RepositoryError> {
unreachable!("MockTaskRepository::find_by_id not invoked by PostgresTaskQueue tests")
}
async fn update(&self, _task: &Task) -> Result<Task, RepositoryError> {
unreachable!("MockTaskRepository::update not invoked by PostgresTaskQueue tests")
}
async fn acquire_next(
&self,
worker_id: crate::domain::id::Id,
) -> Result<Option<Task>, RepositoryError> {
self.dequeue_calls.fetch_add(1, Ordering::SeqCst);
*self.last_worker_id.lock() = Some(worker_id);
if self.should_fail {
return Err(db_error());
}
Ok(self.next_task.lock().take())
}
async fn mark_completed(
&self,
task_id: crate::domain::id::Id,
_lock_token: Option<crate::domain::id::Id>,
) -> Result<u64, RepositoryError> {
self.complete_calls.fetch_add(1, Ordering::SeqCst);
*self.last_task_id.lock() = Some(task_id);
if self.should_fail {
return Err(db_error());
}
Ok(1)
}
async fn mark_failed(
&self,
task_id: crate::domain::id::Id,
_lock_token: Option<crate::domain::id::Id>,
) -> Result<u64, RepositoryError> {
self.fail_calls.fetch_add(1, Ordering::SeqCst);
*self.last_task_id.lock() = Some(task_id);
if self.should_fail {
return Err(db_error());
}
Ok(1)
}
async fn mark_cancelled(
&self,
task_id: crate::domain::id::Id,
) -> Result<u64, RepositoryError> {
self.cancel_calls.fetch_add(1, Ordering::SeqCst);
*self.last_task_id.lock() = Some(task_id);
if self.should_fail {
return Err(db_error());
}
Ok(1)
}
async fn exists_by_url(&self, _url: &str) -> Result<bool, RepositoryError> {
unreachable!("MockTaskRepository::exists_by_url not invoked by PostgresTaskQueue tests")
}
async fn find_existing_urls(
&self,
_urls: &[String],
) -> Result<HashSet<String>, RepositoryError> {
unreachable!(
"MockTaskRepository::find_existing_urls not invoked by PostgresTaskQueue tests"
)
}
async fn reset_stuck_tasks(
&self,
_timeout: ChronoDuration,
) -> Result<u64, RepositoryError> {
unreachable!(
"MockTaskRepository::reset_stuck_tasks not invoked by PostgresTaskQueue tests"
)
}
async fn cancel_tasks_by_crawl_id(
&self,
_crawl_id: crate::domain::id::Id,
) -> Result<u64, RepositoryError> {
unreachable!("MockTaskRepository::cancel_tasks_by_crawl_id not invoked by PostgresTaskQueue tests")
}
async fn expire_tasks(&self) -> Result<u64, RepositoryError> {
unreachable!("MockTaskRepository::expire_tasks not invoked by PostgresTaskQueue tests")
}
async fn find_by_crawl_id(
&self,
_crawl_id: crate::domain::id::Id,
) -> Result<Vec<Task>, RepositoryError> {
unreachable!(
"MockTaskRepository::find_by_crawl_id not invoked by PostgresTaskQueue tests"
)
}
async fn query_tasks(
&self,
_params: TaskQueryParams,
) -> Result<(Vec<Task>, u64), RepositoryError> {
unreachable!("MockTaskRepository::query_tasks not invoked by PostgresTaskQueue tests")
}
async fn batch_cancel(
&self,
_task_ids: Vec<crate::domain::id::Id>,
_team_id: crate::domain::id::Id,
_force: bool,
) -> Result<
(
Vec<crate::domain::id::Id>,
Vec<(crate::domain::id::Id, String)>,
),
RepositoryError,
> {
unreachable!("MockTaskRepository::batch_cancel not invoked by PostgresTaskQueue tests")
}
async fn renew_lock(
&self,
_task_id: crate::domain::id::Id,
_worker_id: crate::domain::id::Id,
_extend_seconds: i64,
) -> Result<bool, RepositoryError> {
Ok(true)
}
}
fn make_queue(mock: Arc<dyn TaskRepository>) -> PostgresTaskQueue {
PostgresTaskQueue::new(mock)
}
#[test]
fn test_new_stores_repository() {
let mock: Arc<dyn TaskRepository> = Arc::new(MockTaskRepository::new());
let queue = make_queue(mock.clone());
assert!(Arc::ptr_eq(&queue.repository, &mock));
}
#[tokio::test]
async fn test_enqueue_returns_created_task() {
let mock = Arc::new(MockTaskRepository::new());
let queue = make_queue(mock.clone());
let task = sample_task();
let result = queue.enqueue(task.clone()).await;
assert!(result.is_ok(), "enqueue should succeed");
let created = result.unwrap();
assert_eq!(created.id, task.id);
assert_eq!(created.url, task.url);
assert_eq!(mock.enqueue_calls.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_enqueue_propagates_repository_error() {
let mock = Arc::new(MockTaskRepository::failing());
let queue = make_queue(mock.clone());
let task = sample_task();
let result = queue.enqueue(task).await;
let err = result.expect_err("should propagate repository error");
match err {
QueueError::Repository(_) => {}
other => panic!("expected QueueError::Repository, got {:?}", other),
}
assert_eq!(mock.enqueue_calls.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_dequeue_empty_returns_none() {
let mock = Arc::new(MockTaskRepository::new());
let queue = make_queue(mock.clone());
let worker_id = crate::domain::id::Id::generate();
let result = queue.dequeue(worker_id).await;
assert!(result.is_ok(), "dequeue on empty queue should succeed");
assert!(result.unwrap().is_none(), "empty queue should return None");
assert_eq!(mock.dequeue_calls.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_dequeue_returns_next_task() {
let task = sample_task();
let mock = Arc::new(MockTaskRepository::with_next_task(task.clone()));
let queue = make_queue(mock.clone());
let worker_id = crate::domain::id::Id::generate();
let result = queue.dequeue(worker_id).await;
let dequeued = result
.expect("dequeue should succeed")
.expect("task expected");
assert_eq!(dequeued.id, task.id);
assert_eq!(*mock.last_worker_id.lock(), Some(worker_id));
}
#[tokio::test]
async fn test_depth_counter_clamps_at_zero_for_repository_direct_enqueues() {
let mock = Arc::new(MockTaskRepository::with_next_task(sample_task()));
let queue = make_queue(mock.clone());
queue
.dequeue(crate::domain::id::Id::generate())
.await
.expect("dequeue should succeed");
assert_eq!(queue.depth.load(Ordering::Relaxed), 0);
queue
.enqueue(sample_task())
.await
.expect("enqueue should succeed");
assert_eq!(queue.depth.load(Ordering::Relaxed), 1);
}
#[tokio::test]
async fn test_dequeue_propagates_repository_error() {
let mock = Arc::new(MockTaskRepository::failing());
let queue = make_queue(mock.clone());
let result = queue.dequeue(crate::domain::id::Id::generate()).await;
let err = result.expect_err("should propagate repository error");
match err {
QueueError::Repository(_) => {}
other => panic!("expected QueueError::Repository, got {:?}", other),
}
assert_eq!(mock.dequeue_calls.load(Ordering::SeqCst), 1);
}
use crate::test_utils::ensure_debug_logger;
#[tokio::test]
async fn test_dequeue_logs_debug_with_task() {
ensure_debug_logger();
let task = sample_task();
let mock = Arc::new(MockTaskRepository::with_next_task(task.clone()));
let queue = make_queue(mock.clone());
let worker_id = crate::domain::id::Id::generate();
let result = queue.dequeue(worker_id).await;
assert!(result.is_ok());
assert_eq!(mock.dequeue_calls.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_dequeue_logs_debug_empty_queue() {
ensure_debug_logger();
let mock = Arc::new(MockTaskRepository::new());
let queue = make_queue(mock.clone());
let worker_id = crate::domain::id::Id::generate();
let result = queue.dequeue(worker_id).await;
assert!(result.is_ok());
assert!(result.unwrap().is_none());
assert_eq!(mock.dequeue_calls.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_complete_calls_repository_and_returns_ok() {
let mock = Arc::new(MockTaskRepository::new());
let queue = make_queue(mock.clone());
let task_id = crate::domain::id::Id::generate();
queue
.complete(task_id)
.await
.expect("complete should succeed");
assert_eq!(mock.complete_calls.load(Ordering::SeqCst), 1);
assert_eq!(*mock.last_task_id.lock(), Some(task_id));
}
#[tokio::test]
async fn test_fail_calls_repository_and_returns_ok() {
let mock = Arc::new(MockTaskRepository::new());
let queue = make_queue(mock.clone());
let task_id = crate::domain::id::Id::generate();
queue.fail(task_id).await.expect("fail should succeed");
assert_eq!(mock.fail_calls.load(Ordering::SeqCst), 1);
assert_eq!(*mock.last_task_id.lock(), Some(task_id));
}
#[tokio::test]
async fn test_cancel_calls_repository_and_returns_ok() {
let mock = Arc::new(MockTaskRepository::new());
let queue = make_queue(mock.clone());
let task_id = crate::domain::id::Id::generate();
queue.cancel(task_id).await.expect("cancel should succeed");
assert_eq!(mock.cancel_calls.load(Ordering::SeqCst), 1);
assert_eq!(*mock.last_task_id.lock(), Some(task_id));
}
#[tokio::test]
async fn test_complete_propagates_repository_error() {
let mock = Arc::new(MockTaskRepository::failing());
let queue = make_queue(mock.clone());
let result = queue.complete(crate::domain::id::Id::generate()).await;
assert!(matches!(result, Err(QueueError::Repository(_))));
assert_eq!(mock.complete_calls.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_fail_propagates_repository_error() {
let mock = Arc::new(MockTaskRepository::failing());
let queue = make_queue(mock.clone());
let result = queue.fail(crate::domain::id::Id::generate()).await;
assert!(matches!(result, Err(QueueError::Repository(_))));
assert_eq!(mock.fail_calls.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_cancel_propagates_repository_error() {
let mock = Arc::new(MockTaskRepository::failing());
let queue = make_queue(mock.clone());
let result = queue.cancel(crate::domain::id::Id::generate()).await;
assert!(matches!(result, Err(QueueError::Repository(_))));
assert_eq!(mock.cancel_calls.load(Ordering::SeqCst), 1);
}
#[test]
fn test_queue_error_repository_display() {
let err = QueueError::Repository(db_error());
let msg = err.to_string();
assert!(msg.contains("Repository error"));
assert!(msg.contains("mock database failure"));
}
#[test]
fn test_queue_error_empty_display() {
let err = QueueError::Empty;
assert_eq!(err.to_string(), "Queue empty");
}
#[test]
fn test_queue_error_repository_from_repository_error() {
let repo_err = db_error();
let queue_err: QueueError = repo_err.into();
match queue_err {
QueueError::Repository(_) => {}
other => panic!("expected QueueError::Repository, got {:?}", other),
}
}
#[tokio::test]
async fn test_arc_delegation_enqueue() {
let mock = Arc::new(MockTaskRepository::new());
let queue: Arc<PostgresTaskQueue> = Arc::new(make_queue(mock.clone()));
let task = sample_task();
let result = queue.enqueue(task).await;
assert!(result.is_ok());
assert_eq!(mock.enqueue_calls.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_arc_delegation_dequeue() {
let mock = Arc::new(MockTaskRepository::new());
let queue = Arc::new(make_queue(mock.clone()));
let worker_id = crate::domain::id::Id::generate();
let result = queue.dequeue(worker_id).await;
assert!(result.is_ok());
assert_eq!(mock.dequeue_calls.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_arc_delegation_complete() {
let mock = Arc::new(MockTaskRepository::new());
let queue = Arc::new(make_queue(mock.clone()));
queue
.complete(crate::domain::id::Id::generate())
.await
.unwrap();
assert_eq!(mock.complete_calls.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_arc_delegation_fail() {
let mock = Arc::new(MockTaskRepository::new());
let queue = Arc::new(make_queue(mock.clone()));
queue.fail(crate::domain::id::Id::generate()).await.unwrap();
assert_eq!(mock.fail_calls.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_arc_delegation_cancel() {
let mock = Arc::new(MockTaskRepository::new());
let queue = Arc::new(make_queue(mock.clone()));
queue
.cancel(crate::domain::id::Id::generate())
.await
.unwrap();
assert_eq!(mock.cancel_calls.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_enqueue_then_dequeue_full_cycle() {
let task = sample_task();
let mock = Arc::new(MockTaskRepository::with_next_task(task.clone()));
let queue = make_queue(mock.clone());
let dequeued = queue
.dequeue(crate::domain::id::Id::generate())
.await
.unwrap();
assert!(
dequeued.is_some(),
"configured next_task should be returned"
);
assert_eq!(dequeued.unwrap().id, task.id);
let second = queue
.dequeue(crate::domain::id::Id::generate())
.await
.unwrap();
assert!(second.is_none(), "second dequeue should return None");
}
#[tokio::test]
async fn test_lifecycle_enqueue_complete_fail_cancel_independent() {
let mock = Arc::new(MockTaskRepository::new());
let queue = make_queue(mock.clone());
let id1 = crate::domain::id::Id::generate();
let id2 = crate::domain::id::Id::generate();
let id3 = crate::domain::id::Id::generate();
queue.complete(id1).await.unwrap();
queue.fail(id2).await.unwrap();
queue.cancel(id3).await.unwrap();
assert_eq!(mock.complete_calls.load(Ordering::SeqCst), 1);
assert_eq!(mock.fail_calls.load(Ordering::SeqCst), 1);
assert_eq!(mock.cancel_calls.load(Ordering::SeqCst), 1);
assert_eq!(*mock.last_task_id.lock(), Some(id3));
}
#[tokio::test]
async fn test_arc_dyn_delegation_enqueue() {
let mock = Arc::new(MockTaskRepository::new());
let queue: Arc<dyn TaskQueue> = Arc::new(make_queue(mock.clone()));
let task = sample_task();
let result = queue.enqueue(task).await;
assert!(result.is_ok());
assert_eq!(mock.enqueue_calls.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_arc_dyn_delegation_dequeue() {
let mock = Arc::new(MockTaskRepository::new());
let queue: Arc<dyn TaskQueue> = Arc::new(make_queue(mock.clone()));
let result = queue.dequeue(crate::domain::id::Id::generate()).await;
assert!(result.is_ok());
assert_eq!(mock.dequeue_calls.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_arc_dyn_delegation_complete() {
let mock = Arc::new(MockTaskRepository::new());
let queue: Arc<dyn TaskQueue> = Arc::new(make_queue(mock.clone()));
queue
.complete(crate::domain::id::Id::generate())
.await
.unwrap();
assert_eq!(mock.complete_calls.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_arc_dyn_delegation_fail() {
let mock = Arc::new(MockTaskRepository::new());
let queue: Arc<dyn TaskQueue> = Arc::new(make_queue(mock.clone()));
queue.fail(crate::domain::id::Id::generate()).await.unwrap();
assert_eq!(mock.fail_calls.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn test_arc_dyn_delegation_cancel() {
let mock = Arc::new(MockTaskRepository::new());
let queue: Arc<dyn TaskQueue> = Arc::new(make_queue(mock.clone()));
queue
.cancel(crate::domain::id::Id::generate())
.await
.unwrap();
assert_eq!(mock.cancel_calls.load(Ordering::SeqCst), 1);
}
}