1use crate::job::{Job, JobOptions, JobResult, JobStatus};
31use crate::queue::Queue;
32use crate::worker::{Worker, WorkerConfig};
33use crate::TaskConfig;
34use std::sync::Arc;
35
36pub struct BaseQueue {
40 pub name: String,
42 pub prefix: String,
44 pub task_config: TaskConfig,
46 pub queue: Arc<Queue>,
48 pub worker: Option<Worker>,
50}
51
52impl BaseQueue {
53 pub async fn new(name: &str, config: TaskConfig) -> JobResult<Self> {
55 let queue = Queue::new(name, &config.prefix, &config.redis_url).await?;
56 let worker_cfg = WorkerConfig {
57 concurrency: config.concurrency,
58 ..Default::default()
59 };
60 let worker = Worker::new(queue.clone(), worker_cfg);
61
62 Ok(Self {
63 name: name.to_string(),
64 prefix: config.prefix.clone(),
65 task_config: config,
66 queue: Arc::new(queue),
67 worker: Some(worker),
68 })
69 }
70
71 pub async fn producer_only(name: &str, config: TaskConfig) -> JobResult<Self> {
73 let queue = Queue::new(name, &config.prefix, &config.redis_url).await?;
74 Ok(Self {
75 name: name.to_string(),
76 prefix: config.prefix.clone(),
77 task_config: config,
78 queue: Arc::new(queue),
79 worker: None,
80 })
81 }
82
83 pub async fn start_worker(&self) {
85 if let Some(worker) = &self.worker {
86 worker.start().await;
87 }
88 }
89
90 pub fn stop_worker(&self) {
92 if let Some(worker) = &self.worker {
93 worker.stop();
94 }
95 }
96
97 pub async fn add(
99 &self,
100 name: &str,
101 data: serde_json::Value,
102 options: JobOptions,
103 ) -> JobResult<Job> {
104 self.queue.add(name, data, options).await
105 }
106
107 pub async fn add_bulk(
109 &self,
110 jobs: Vec<(String, serde_json::Value, JobOptions)>,
111 ) -> JobResult<Vec<Job>> {
112 self.queue.add_bulk(jobs).await
113 }
114
115 pub async fn pause(&self) -> JobResult<()> {
117 self.queue.pause().await
118 }
119
120 pub async fn resume(&self) -> JobResult<()> {
122 self.queue.resume().await
123 }
124
125 pub async fn is_paused(&self) -> JobResult<bool> {
127 self.queue.is_paused().await
128 }
129
130 pub async fn count(&self, status: JobStatus) -> JobResult<u64> {
132 self.queue.count(status).await
133 }
134
135 pub async fn obliterate(&self) -> JobResult<()> {
137 self.queue.obliterate().await
138 }
139}