2022-08-05 07:06:32 +00:00
|
|
|
use crate::asynk::async_runnable::AsyncRunnable;
|
2022-08-29 16:59:22 +00:00
|
|
|
use crate::CronError;
|
|
|
|
use crate::Scheduled::*;
|
2022-07-23 14:24:22 +00:00
|
|
|
use async_trait::async_trait;
|
2022-07-17 16:22:00 +00:00
|
|
|
use bb8_postgres::bb8::Pool;
|
|
|
|
use bb8_postgres::bb8::RunError;
|
2022-07-19 13:49:43 +00:00
|
|
|
use bb8_postgres::tokio_postgres::row::Row;
|
2022-07-27 17:05:05 +00:00
|
|
|
use bb8_postgres::tokio_postgres::tls::{MakeTlsConnect, TlsConnect};
|
2022-07-17 16:22:00 +00:00
|
|
|
use bb8_postgres::tokio_postgres::Socket;
|
2022-07-17 19:34:55 +00:00
|
|
|
use bb8_postgres::tokio_postgres::Transaction;
|
2022-07-17 16:22:00 +00:00
|
|
|
use bb8_postgres::PostgresConnectionManager;
|
2022-07-19 13:49:43 +00:00
|
|
|
use chrono::DateTime;
|
2022-07-18 10:44:05 +00:00
|
|
|
use chrono::Utc;
|
2022-08-27 15:58:38 +00:00
|
|
|
use cron::Schedule;
|
2022-07-19 13:49:43 +00:00
|
|
|
use postgres_types::{FromSql, ToSql};
|
2022-08-27 15:58:38 +00:00
|
|
|
use sha2::{Digest, Sha256};
|
|
|
|
use std::str::FromStr;
|
2022-07-17 16:22:00 +00:00
|
|
|
use thiserror::Error;
|
|
|
|
use typed_builder::TypedBuilder;
|
2022-07-19 13:49:43 +00:00
|
|
|
use uuid::Uuid;
|
2022-07-17 07:13:45 +00:00
|
|
|
|
2022-08-05 07:06:32 +00:00
|
|
|
#[cfg(test)]
|
|
|
|
use bb8_postgres::tokio_postgres::tls::NoTls;
|
|
|
|
|
2022-07-19 20:05:09 +00:00
|
|
|
const INSERT_TASK_QUERY: &str = include_str!("queries/insert_task.sql");
|
2022-08-27 15:58:38 +00:00
|
|
|
const INSERT_TASK_UNIQ_QUERY: &str = include_str!("queries/insert_task_uniq.sql");
|
2022-07-19 20:05:09 +00:00
|
|
|
const UPDATE_TASK_STATE_QUERY: &str = include_str!("queries/update_task_state.sql");
|
|
|
|
const FAIL_TASK_QUERY: &str = include_str!("queries/fail_task.sql");
|
|
|
|
const REMOVE_ALL_TASK_QUERY: &str = include_str!("queries/remove_all_tasks.sql");
|
2022-08-31 23:01:15 +00:00
|
|
|
const REMOVE_ALL_SCHEDULED_TASK_QUERY: &str =
|
|
|
|
include_str!("queries/remove_all_scheduled_tasks.sql");
|
2022-07-19 20:05:09 +00:00
|
|
|
const REMOVE_TASK_QUERY: &str = include_str!("queries/remove_task.sql");
|
|
|
|
const REMOVE_TASKS_TYPE_QUERY: &str = include_str!("queries/remove_tasks_type.sql");
|
|
|
|
const FETCH_TASK_TYPE_QUERY: &str = include_str!("queries/fetch_task_type.sql");
|
2022-08-27 15:58:38 +00:00
|
|
|
const FIND_TASK_BY_UNIQ_HASH_QUERY: &str = include_str!("queries/find_task_by_uniq_hash.sql");
|
2022-07-31 11:40:24 +00:00
|
|
|
const FIND_TASK_BY_ID_QUERY: &str = include_str!("queries/find_task_by_id.sql");
|
2022-07-19 20:05:09 +00:00
|
|
|
|
2022-07-27 17:05:05 +00:00
|
|
|
pub const DEFAULT_TASK_TYPE: &str = "common";
|
2022-07-19 20:05:09 +00:00
|
|
|
|
2022-07-19 13:49:43 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Clone, ToSql, FromSql)]
|
|
|
|
#[postgres(name = "fang_task_state")]
|
|
|
|
pub enum FangTaskState {
|
|
|
|
#[postgres(name = "new")]
|
|
|
|
New,
|
|
|
|
#[postgres(name = "in_progress")]
|
|
|
|
InProgress,
|
|
|
|
#[postgres(name = "failed")]
|
|
|
|
Failed,
|
|
|
|
#[postgres(name = "finished")]
|
|
|
|
Finished,
|
|
|
|
}
|
2022-07-31 11:40:24 +00:00
|
|
|
|
2022-07-19 13:49:43 +00:00
|
|
|
impl Default for FangTaskState {
|
|
|
|
fn default() -> Self {
|
|
|
|
FangTaskState::New
|
|
|
|
}
|
|
|
|
}
|
2022-07-31 11:40:24 +00:00
|
|
|
|
2022-07-19 13:49:43 +00:00
|
|
|
#[derive(TypedBuilder, Debug, Eq, PartialEq, Clone)]
|
|
|
|
pub struct Task {
|
|
|
|
#[builder(setter(into))]
|
|
|
|
pub id: Uuid,
|
|
|
|
#[builder(setter(into))]
|
|
|
|
pub metadata: serde_json::Value,
|
|
|
|
#[builder(setter(into))]
|
|
|
|
pub error_message: Option<String>,
|
|
|
|
#[builder(default, setter(into))]
|
|
|
|
pub state: FangTaskState,
|
|
|
|
#[builder(setter(into))]
|
|
|
|
pub task_type: String,
|
|
|
|
#[builder(setter(into))]
|
2022-08-27 15:58:38 +00:00
|
|
|
pub uniq_hash: Option<String>,
|
2022-07-19 13:49:43 +00:00
|
|
|
#[builder(setter(into))]
|
2022-08-27 15:58:38 +00:00
|
|
|
pub scheduled_at: DateTime<Utc>,
|
2022-07-19 13:49:43 +00:00
|
|
|
#[builder(setter(into))]
|
|
|
|
pub created_at: DateTime<Utc>,
|
|
|
|
#[builder(setter(into))]
|
|
|
|
pub updated_at: DateTime<Utc>,
|
|
|
|
}
|
|
|
|
|
2022-07-17 19:34:55 +00:00
|
|
|
#[derive(Debug, Error)]
|
2022-07-17 16:22:00 +00:00
|
|
|
pub enum AsyncQueueError {
|
|
|
|
#[error(transparent)]
|
|
|
|
PoolError(#[from] RunError<bb8_postgres::tokio_postgres::Error>),
|
|
|
|
#[error(transparent)]
|
|
|
|
PgError(#[from] bb8_postgres::tokio_postgres::Error),
|
2022-07-31 15:15:00 +00:00
|
|
|
#[error(transparent)]
|
|
|
|
SerdeError(#[from] serde_json::Error),
|
2022-08-27 15:58:38 +00:00
|
|
|
#[error(transparent)]
|
|
|
|
CronError(#[from] CronError),
|
2022-07-17 16:22:00 +00:00
|
|
|
#[error("returned invalid result (expected {expected:?}, found {found:?})")]
|
|
|
|
ResultError { expected: u64, found: u64 },
|
2022-08-01 19:37:32 +00:00
|
|
|
#[error(
|
|
|
|
"AsyncQueue is not connected :( , call connect() method first and then perform operations"
|
|
|
|
)]
|
|
|
|
NotConnectedError,
|
2022-08-18 11:39:10 +00:00
|
|
|
#[error("Can not convert `std::time::Duration` to `chrono::Duration`")]
|
|
|
|
TimeError,
|
2022-07-17 07:13:45 +00:00
|
|
|
}
|
2022-07-31 11:40:24 +00:00
|
|
|
|
2022-08-27 15:58:38 +00:00
|
|
|
impl From<cron::error::Error> for AsyncQueueError {
|
|
|
|
fn from(error: cron::error::Error) -> Self {
|
|
|
|
AsyncQueueError::CronError(CronError::LibraryError(error))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-07-23 14:24:22 +00:00
|
|
|
#[async_trait]
|
2022-07-31 13:32:37 +00:00
|
|
|
pub trait AsyncQueueable: Send {
|
2022-07-23 14:24:22 +00:00
|
|
|
async fn fetch_and_touch_task(
|
|
|
|
&mut self,
|
2022-07-31 11:40:24 +00:00
|
|
|
task_type: Option<String>,
|
2022-07-23 14:24:22 +00:00
|
|
|
) -> Result<Option<Task>, AsyncQueueError>;
|
|
|
|
|
2022-07-31 15:15:00 +00:00
|
|
|
async fn insert_task(&mut self, task: &dyn AsyncRunnable) -> Result<Task, AsyncQueueError>;
|
2022-08-27 15:58:38 +00:00
|
|
|
|
2022-07-23 14:24:22 +00:00
|
|
|
async fn remove_all_tasks(&mut self) -> Result<u64, AsyncQueueError>;
|
|
|
|
|
2022-08-31 23:01:15 +00:00
|
|
|
async fn remove_all_scheduled_tasks(&mut self) -> Result<u64, AsyncQueueError>;
|
|
|
|
|
2022-07-23 14:24:22 +00:00
|
|
|
async fn remove_task(&mut self, task: Task) -> Result<u64, AsyncQueueError>;
|
|
|
|
|
|
|
|
async fn remove_tasks_type(&mut self, task_type: &str) -> Result<u64, AsyncQueueError>;
|
|
|
|
|
2022-08-27 15:58:38 +00:00
|
|
|
async fn find_task_by_id(&mut self, id: Uuid) -> Result<Task, AsyncQueueError>;
|
|
|
|
|
2022-07-23 14:24:22 +00:00
|
|
|
async fn update_task_state(
|
|
|
|
&mut self,
|
|
|
|
task: Task,
|
|
|
|
state: FangTaskState,
|
|
|
|
) -> Result<Task, AsyncQueueError>;
|
|
|
|
|
|
|
|
async fn fail_task(&mut self, task: Task, error_message: &str)
|
|
|
|
-> Result<Task, AsyncQueueError>;
|
2022-07-31 11:40:24 +00:00
|
|
|
|
2022-08-27 15:58:38 +00:00
|
|
|
async fn schedule_task(&mut self, task: &dyn AsyncRunnable) -> Result<Task, AsyncQueueError>;
|
2022-07-23 14:24:22 +00:00
|
|
|
}
|
|
|
|
|
2022-07-31 11:40:24 +00:00
|
|
|
#[derive(TypedBuilder, Debug, Clone)]
|
2022-07-19 20:05:09 +00:00
|
|
|
pub struct AsyncQueue<Tls>
|
2022-07-17 16:22:00 +00:00
|
|
|
where
|
|
|
|
Tls: MakeTlsConnect<Socket> + Clone + Send + Sync + 'static,
|
|
|
|
<Tls as MakeTlsConnect<Socket>>::Stream: Send + Sync,
|
|
|
|
<Tls as MakeTlsConnect<Socket>>::TlsConnect: Send,
|
|
|
|
<<Tls as MakeTlsConnect<Socket>>::TlsConnect as TlsConnect<Socket>>::Future: Send,
|
|
|
|
{
|
2022-08-01 19:37:32 +00:00
|
|
|
#[builder(default=None, setter(skip))]
|
|
|
|
pool: Option<Pool<PostgresConnectionManager<Tls>>>,
|
2022-07-31 11:40:24 +00:00
|
|
|
#[builder(setter(into))]
|
2022-08-01 19:37:32 +00:00
|
|
|
uri: String,
|
|
|
|
#[builder(setter(into))]
|
|
|
|
max_pool_size: u32,
|
|
|
|
#[builder(default = false, setter(skip))]
|
|
|
|
connected: bool,
|
2022-07-17 16:22:00 +00:00
|
|
|
}
|
|
|
|
|
2022-07-27 17:05:05 +00:00
|
|
|
#[cfg(test)]
|
2022-07-31 11:40:24 +00:00
|
|
|
#[derive(TypedBuilder)]
|
2022-07-27 17:05:05 +00:00
|
|
|
pub struct AsyncQueueTest<'a> {
|
2022-07-31 11:40:24 +00:00
|
|
|
#[builder(setter(into))]
|
2022-07-27 17:05:05 +00:00
|
|
|
pub transaction: Transaction<'a>,
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(test)]
|
2022-08-27 15:58:38 +00:00
|
|
|
#[async_trait]
|
|
|
|
impl AsyncQueueable for AsyncQueueTest<'_> {
|
|
|
|
async fn find_task_by_id(&mut self, id: Uuid) -> Result<Task, AsyncQueueError> {
|
|
|
|
let transaction = &mut self.transaction;
|
2022-07-31 11:40:24 +00:00
|
|
|
|
2022-08-27 15:58:38 +00:00
|
|
|
AsyncQueue::<NoTls>::find_task_by_id_query(transaction, id).await
|
2022-07-31 11:40:24 +00:00
|
|
|
}
|
2022-07-27 17:05:05 +00:00
|
|
|
|
|
|
|
async fn fetch_and_touch_task(
|
|
|
|
&mut self,
|
2022-07-31 11:40:24 +00:00
|
|
|
task_type: Option<String>,
|
2022-07-27 17:05:05 +00:00
|
|
|
) -> Result<Option<Task>, AsyncQueueError> {
|
|
|
|
let transaction = &mut self.transaction;
|
|
|
|
|
2022-08-27 15:58:38 +00:00
|
|
|
AsyncQueue::<NoTls>::fetch_and_touch_task_query(transaction, task_type).await
|
2022-07-27 17:05:05 +00:00
|
|
|
}
|
|
|
|
|
2022-07-31 15:15:00 +00:00
|
|
|
async fn insert_task(&mut self, task: &dyn AsyncRunnable) -> Result<Task, AsyncQueueError> {
|
2022-07-27 17:05:05 +00:00
|
|
|
let transaction = &mut self.transaction;
|
|
|
|
|
2022-07-31 15:15:00 +00:00
|
|
|
let metadata = serde_json::to_value(task)?;
|
|
|
|
|
2022-08-27 15:58:38 +00:00
|
|
|
let task: Task = if !task.uniq() {
|
|
|
|
AsyncQueue::<NoTls>::insert_task_query(
|
|
|
|
transaction,
|
|
|
|
metadata,
|
|
|
|
&task.task_type(),
|
|
|
|
Utc::now(),
|
|
|
|
)
|
|
|
|
.await?
|
2022-07-31 11:40:24 +00:00
|
|
|
} else {
|
2022-07-31 15:15:00 +00:00
|
|
|
AsyncQueue::<NoTls>::insert_task_if_not_exist_query(
|
|
|
|
transaction,
|
|
|
|
metadata,
|
|
|
|
&task.task_type(),
|
2022-08-27 15:58:38 +00:00
|
|
|
Utc::now(),
|
2022-07-31 15:15:00 +00:00
|
|
|
)
|
|
|
|
.await?
|
2022-07-31 11:40:24 +00:00
|
|
|
};
|
2022-07-27 17:05:05 +00:00
|
|
|
Ok(task)
|
|
|
|
}
|
|
|
|
|
2022-08-27 15:58:38 +00:00
|
|
|
async fn schedule_task(&mut self, task: &dyn AsyncRunnable) -> Result<Task, AsyncQueueError> {
|
2022-07-31 11:40:24 +00:00
|
|
|
let transaction = &mut self.transaction;
|
|
|
|
|
2022-07-31 15:15:00 +00:00
|
|
|
let metadata = serde_json::to_value(task)?;
|
|
|
|
|
2022-08-27 15:58:38 +00:00
|
|
|
let scheduled_at = match task.cron() {
|
|
|
|
Some(scheduled) => match scheduled {
|
|
|
|
CronPattern(cron_pattern) => {
|
|
|
|
let schedule = Schedule::from_str(&cron_pattern)?;
|
|
|
|
let mut iterator = schedule.upcoming(Utc);
|
|
|
|
|
|
|
|
iterator
|
|
|
|
.next()
|
|
|
|
.ok_or(AsyncQueueError::CronError(CronError::NoTimestampsError))?
|
|
|
|
}
|
|
|
|
ScheduleOnce(datetime) => datetime,
|
|
|
|
},
|
|
|
|
None => {
|
|
|
|
return Err(AsyncQueueError::CronError(
|
|
|
|
CronError::TaskNotSchedulableError,
|
|
|
|
));
|
|
|
|
}
|
|
|
|
};
|
2022-07-31 11:40:24 +00:00
|
|
|
|
2022-08-27 15:58:38 +00:00
|
|
|
let task: Task = if !task.uniq() {
|
|
|
|
AsyncQueue::<NoTls>::insert_task_query(
|
|
|
|
transaction,
|
|
|
|
metadata,
|
|
|
|
&task.task_type(),
|
|
|
|
scheduled_at,
|
|
|
|
)
|
|
|
|
.await?
|
|
|
|
} else {
|
|
|
|
AsyncQueue::<NoTls>::insert_task_if_not_exist_query(
|
|
|
|
transaction,
|
|
|
|
metadata,
|
|
|
|
&task.task_type(),
|
|
|
|
scheduled_at,
|
|
|
|
)
|
|
|
|
.await?
|
|
|
|
};
|
2022-07-31 11:40:24 +00:00
|
|
|
|
2022-08-27 15:58:38 +00:00
|
|
|
Ok(task)
|
2022-07-31 11:40:24 +00:00
|
|
|
}
|
2022-07-27 17:05:05 +00:00
|
|
|
async fn remove_all_tasks(&mut self) -> Result<u64, AsyncQueueError> {
|
|
|
|
let transaction = &mut self.transaction;
|
|
|
|
|
2022-08-27 15:58:38 +00:00
|
|
|
AsyncQueue::<NoTls>::remove_all_tasks_query(transaction).await
|
2022-07-27 17:05:05 +00:00
|
|
|
}
|
|
|
|
|
2022-08-31 23:01:15 +00:00
|
|
|
async fn remove_all_scheduled_tasks(&mut self) -> Result<u64, AsyncQueueError> {
|
|
|
|
let transaction = &mut self.transaction;
|
|
|
|
|
|
|
|
AsyncQueue::<NoTls>::remove_all_scheduled_tasks_query(transaction).await
|
|
|
|
}
|
|
|
|
|
2022-07-27 17:05:05 +00:00
|
|
|
async fn remove_task(&mut self, task: Task) -> Result<u64, AsyncQueueError> {
|
|
|
|
let transaction = &mut self.transaction;
|
|
|
|
|
2022-08-27 15:58:38 +00:00
|
|
|
AsyncQueue::<NoTls>::remove_task_query(transaction, task).await
|
2022-07-27 17:05:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
async fn remove_tasks_type(&mut self, task_type: &str) -> Result<u64, AsyncQueueError> {
|
|
|
|
let transaction = &mut self.transaction;
|
|
|
|
|
2022-08-27 15:58:38 +00:00
|
|
|
AsyncQueue::<NoTls>::remove_tasks_type_query(transaction, task_type).await
|
2022-07-27 17:05:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
async fn update_task_state(
|
|
|
|
&mut self,
|
|
|
|
task: Task,
|
|
|
|
state: FangTaskState,
|
|
|
|
) -> Result<Task, AsyncQueueError> {
|
|
|
|
let transaction = &mut self.transaction;
|
|
|
|
|
2022-08-27 15:58:38 +00:00
|
|
|
AsyncQueue::<NoTls>::update_task_state_query(transaction, task, state).await
|
2022-07-27 17:05:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
async fn fail_task(
|
|
|
|
&mut self,
|
|
|
|
task: Task,
|
|
|
|
error_message: &str,
|
|
|
|
) -> Result<Task, AsyncQueueError> {
|
|
|
|
let transaction = &mut self.transaction;
|
|
|
|
|
2022-08-27 15:58:38 +00:00
|
|
|
AsyncQueue::<NoTls>::fail_task_query(transaction, task, error_message).await
|
2022-07-27 17:05:05 +00:00
|
|
|
}
|
|
|
|
}
|
2022-08-05 07:06:32 +00:00
|
|
|
|
2022-07-19 20:05:09 +00:00
|
|
|
impl<Tls> AsyncQueue<Tls>
|
2022-07-17 16:22:00 +00:00
|
|
|
where
|
|
|
|
Tls: MakeTlsConnect<Socket> + Clone + Send + Sync + 'static,
|
|
|
|
<Tls as MakeTlsConnect<Socket>>::Stream: Send + Sync,
|
|
|
|
<Tls as MakeTlsConnect<Socket>>::TlsConnect: Send,
|
|
|
|
<<Tls as MakeTlsConnect<Socket>>::TlsConnect as TlsConnect<Socket>>::Future: Send,
|
|
|
|
{
|
2022-08-01 19:37:32 +00:00
|
|
|
pub fn check_if_connection(&self) -> Result<(), AsyncQueueError> {
|
|
|
|
if self.connected {
|
|
|
|
Ok(())
|
|
|
|
} else {
|
|
|
|
Err(AsyncQueueError::NotConnectedError)
|
|
|
|
}
|
2022-07-20 10:01:33 +00:00
|
|
|
}
|
2022-08-01 19:37:32 +00:00
|
|
|
pub async fn connect(&mut self, tls: Tls) -> Result<(), AsyncQueueError> {
|
|
|
|
let manager = PostgresConnectionManager::new_from_stringlike(self.uri.clone(), tls)?;
|
2022-07-20 10:01:33 +00:00
|
|
|
|
2022-08-01 19:37:32 +00:00
|
|
|
let pool = Pool::builder()
|
|
|
|
.max_size(self.max_pool_size)
|
|
|
|
.build(manager)
|
|
|
|
.await?;
|
|
|
|
|
|
|
|
self.pool = Some(pool);
|
|
|
|
self.connected = true;
|
|
|
|
Ok(())
|
|
|
|
}
|
2022-07-31 15:15:00 +00:00
|
|
|
async fn remove_all_tasks_query(
|
2022-07-20 10:01:33 +00:00
|
|
|
transaction: &mut Transaction<'_>,
|
|
|
|
) -> Result<u64, AsyncQueueError> {
|
|
|
|
Self::execute_query(transaction, REMOVE_ALL_TASK_QUERY, &[], None).await
|
|
|
|
}
|
|
|
|
|
2022-08-31 23:01:15 +00:00
|
|
|
async fn remove_all_scheduled_tasks_query(
|
|
|
|
transaction: &mut Transaction<'_>,
|
|
|
|
) -> Result<u64, AsyncQueueError> {
|
|
|
|
Self::execute_query(
|
|
|
|
transaction,
|
|
|
|
REMOVE_ALL_SCHEDULED_TASK_QUERY,
|
|
|
|
&[&Utc::now()],
|
|
|
|
None,
|
|
|
|
)
|
|
|
|
.await
|
|
|
|
}
|
|
|
|
|
2022-07-31 15:15:00 +00:00
|
|
|
async fn remove_task_query(
|
2022-07-20 10:01:33 +00:00
|
|
|
transaction: &mut Transaction<'_>,
|
2022-07-23 14:24:22 +00:00
|
|
|
task: Task,
|
2022-07-20 10:01:33 +00:00
|
|
|
) -> Result<u64, AsyncQueueError> {
|
|
|
|
Self::execute_query(transaction, REMOVE_TASK_QUERY, &[&task.id], Some(1)).await
|
2022-07-18 10:44:05 +00:00
|
|
|
}
|
2022-07-19 20:05:09 +00:00
|
|
|
|
2022-07-31 15:15:00 +00:00
|
|
|
async fn remove_tasks_type_query(
|
2022-07-20 10:01:33 +00:00
|
|
|
transaction: &mut Transaction<'_>,
|
|
|
|
task_type: &str,
|
|
|
|
) -> Result<u64, AsyncQueueError> {
|
|
|
|
Self::execute_query(transaction, REMOVE_TASKS_TYPE_QUERY, &[&task_type], None).await
|
|
|
|
}
|
|
|
|
|
2022-08-27 15:58:38 +00:00
|
|
|
async fn find_task_by_id_query(
|
|
|
|
transaction: &mut Transaction<'_>,
|
|
|
|
id: Uuid,
|
|
|
|
) -> Result<Task, AsyncQueueError> {
|
|
|
|
let row: Row = transaction.query_one(FIND_TASK_BY_ID_QUERY, &[&id]).await?;
|
|
|
|
|
|
|
|
let task = Self::row_to_task(row);
|
|
|
|
Ok(task)
|
|
|
|
}
|
|
|
|
|
2022-07-31 15:15:00 +00:00
|
|
|
async fn fail_task_query(
|
2022-07-20 10:01:33 +00:00
|
|
|
transaction: &mut Transaction<'_>,
|
2022-07-20 15:26:11 +00:00
|
|
|
task: Task,
|
2022-07-20 10:01:33 +00:00
|
|
|
error_message: &str,
|
2022-07-20 15:26:11 +00:00
|
|
|
) -> Result<Task, AsyncQueueError> {
|
2022-07-18 10:44:05 +00:00
|
|
|
let updated_at = Utc::now();
|
2022-07-20 10:01:33 +00:00
|
|
|
|
2022-07-20 15:26:11 +00:00
|
|
|
let row: Row = transaction
|
|
|
|
.query_one(
|
|
|
|
FAIL_TASK_QUERY,
|
|
|
|
&[
|
|
|
|
&FangTaskState::Failed,
|
|
|
|
&error_message,
|
|
|
|
&updated_at,
|
|
|
|
&task.id,
|
|
|
|
],
|
|
|
|
)
|
|
|
|
.await?;
|
|
|
|
let failed_task = Self::row_to_task(row);
|
|
|
|
Ok(failed_task)
|
2022-07-18 10:44:05 +00:00
|
|
|
}
|
2022-07-17 16:22:00 +00:00
|
|
|
|
2022-07-31 15:15:00 +00:00
|
|
|
async fn fetch_and_touch_task_query(
|
2022-07-19 20:05:09 +00:00
|
|
|
transaction: &mut Transaction<'_>,
|
2022-07-31 11:40:24 +00:00
|
|
|
task_type: Option<String>,
|
2022-07-23 14:24:22 +00:00
|
|
|
) -> Result<Option<Task>, AsyncQueueError> {
|
2022-07-20 10:01:33 +00:00
|
|
|
let task_type = match task_type {
|
|
|
|
Some(passed_task_type) => passed_task_type,
|
2022-07-31 11:40:24 +00:00
|
|
|
None => DEFAULT_TASK_TYPE.to_string(),
|
2022-07-17 16:22:00 +00:00
|
|
|
};
|
2022-07-19 20:05:09 +00:00
|
|
|
|
2022-07-31 11:40:24 +00:00
|
|
|
let task = match Self::get_task_type_query(transaction, &task_type).await {
|
2022-07-23 14:24:22 +00:00
|
|
|
Ok(some_task) => Some(some_task),
|
|
|
|
Err(_) => None,
|
|
|
|
};
|
|
|
|
let result_task = if let Some(some_task) = task {
|
|
|
|
Some(
|
|
|
|
Self::update_task_state_query(transaction, some_task, FangTaskState::InProgress)
|
|
|
|
.await?,
|
|
|
|
)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
};
|
|
|
|
Ok(result_task)
|
2022-07-19 20:05:09 +00:00
|
|
|
}
|
|
|
|
|
2022-07-31 15:15:00 +00:00
|
|
|
async fn get_task_type_query(
|
2022-07-19 20:05:09 +00:00
|
|
|
transaction: &mut Transaction<'_>,
|
|
|
|
task_type: &str,
|
|
|
|
) -> Result<Task, AsyncQueueError> {
|
|
|
|
let row: Row = transaction
|
2022-08-27 15:58:38 +00:00
|
|
|
.query_one(FETCH_TASK_TYPE_QUERY, &[&task_type, &Utc::now()])
|
2022-07-19 20:05:09 +00:00
|
|
|
.await?;
|
|
|
|
|
|
|
|
let task = Self::row_to_task(row);
|
|
|
|
|
|
|
|
Ok(task)
|
|
|
|
}
|
|
|
|
|
2022-07-31 15:15:00 +00:00
|
|
|
async fn update_task_state_query(
|
2022-07-19 20:05:09 +00:00
|
|
|
transaction: &mut Transaction<'_>,
|
2022-07-23 14:24:22 +00:00
|
|
|
task: Task,
|
2022-07-19 20:05:09 +00:00
|
|
|
state: FangTaskState,
|
2022-07-23 14:24:22 +00:00
|
|
|
) -> Result<Task, AsyncQueueError> {
|
2022-07-19 20:05:09 +00:00
|
|
|
let updated_at = Utc::now();
|
|
|
|
|
2022-07-23 14:24:22 +00:00
|
|
|
let row: Row = transaction
|
|
|
|
.query_one(UPDATE_TASK_STATE_QUERY, &[&state, &updated_at, &task.id])
|
|
|
|
.await?;
|
|
|
|
let task = Self::row_to_task(row);
|
|
|
|
Ok(task)
|
2022-07-19 20:05:09 +00:00
|
|
|
}
|
|
|
|
|
2022-07-31 15:15:00 +00:00
|
|
|
async fn insert_task_query(
|
2022-07-19 20:05:09 +00:00
|
|
|
transaction: &mut Transaction<'_>,
|
2022-07-23 14:24:22 +00:00
|
|
|
metadata: serde_json::Value,
|
|
|
|
task_type: &str,
|
2022-08-27 15:58:38 +00:00
|
|
|
scheduled_at: DateTime<Utc>,
|
2022-07-20 14:27:01 +00:00
|
|
|
) -> Result<Task, AsyncQueueError> {
|
|
|
|
let row: Row = transaction
|
2022-08-27 15:58:38 +00:00
|
|
|
.query_one(INSERT_TASK_QUERY, &[&metadata, &task_type, &scheduled_at])
|
2022-07-20 14:27:01 +00:00
|
|
|
.await?;
|
|
|
|
let task = Self::row_to_task(row);
|
|
|
|
Ok(task)
|
2022-07-19 20:05:09 +00:00
|
|
|
}
|
2022-08-05 07:06:32 +00:00
|
|
|
|
2022-08-27 15:58:38 +00:00
|
|
|
async fn insert_task_uniq_query(
|
2022-07-31 11:40:24 +00:00
|
|
|
transaction: &mut Transaction<'_>,
|
|
|
|
metadata: serde_json::Value,
|
2022-08-27 15:58:38 +00:00
|
|
|
task_type: &str,
|
|
|
|
scheduled_at: DateTime<Utc>,
|
|
|
|
) -> Result<Task, AsyncQueueError> {
|
|
|
|
let uniq_hash = Self::calculate_hash(metadata.to_string());
|
|
|
|
|
2022-07-31 11:40:24 +00:00
|
|
|
let row: Row = transaction
|
|
|
|
.query_one(
|
2022-08-27 15:58:38 +00:00
|
|
|
INSERT_TASK_UNIQ_QUERY,
|
|
|
|
&[&metadata, &task_type, &uniq_hash, &scheduled_at],
|
2022-07-31 11:40:24 +00:00
|
|
|
)
|
|
|
|
.await?;
|
|
|
|
|
2022-08-27 15:58:38 +00:00
|
|
|
let task = Self::row_to_task(row);
|
|
|
|
Ok(task)
|
2022-07-31 11:40:24 +00:00
|
|
|
}
|
2022-08-05 07:06:32 +00:00
|
|
|
|
2022-07-31 15:15:00 +00:00
|
|
|
async fn execute_query(
|
2022-07-19 20:05:09 +00:00
|
|
|
transaction: &mut Transaction<'_>,
|
|
|
|
query: &str,
|
|
|
|
params: &[&(dyn ToSql + Sync)],
|
|
|
|
expected_result_count: Option<u64>,
|
|
|
|
) -> Result<u64, AsyncQueueError> {
|
|
|
|
let result = transaction.execute(query, params).await?;
|
|
|
|
|
2022-07-18 10:44:05 +00:00
|
|
|
if let Some(expected_result) = expected_result_count {
|
|
|
|
if result != expected_result {
|
|
|
|
return Err(AsyncQueueError::ResultError {
|
|
|
|
expected: expected_result,
|
|
|
|
found: result,
|
|
|
|
});
|
|
|
|
}
|
2022-07-17 16:22:00 +00:00
|
|
|
}
|
|
|
|
Ok(result)
|
|
|
|
}
|
2022-07-19 20:05:09 +00:00
|
|
|
|
2022-07-31 15:15:00 +00:00
|
|
|
async fn insert_task_if_not_exist_query(
|
2022-07-31 11:40:24 +00:00
|
|
|
transaction: &mut Transaction<'_>,
|
|
|
|
metadata: serde_json::Value,
|
|
|
|
task_type: &str,
|
2022-08-27 15:58:38 +00:00
|
|
|
scheduled_at: DateTime<Utc>,
|
2022-07-31 11:40:24 +00:00
|
|
|
) -> Result<Task, AsyncQueueError> {
|
2022-08-27 15:58:38 +00:00
|
|
|
match Self::find_task_by_uniq_hash_query(transaction, &metadata).await {
|
2022-07-31 11:40:24 +00:00
|
|
|
Some(task) => Ok(task),
|
2022-08-27 15:58:38 +00:00
|
|
|
None => {
|
|
|
|
Self::insert_task_uniq_query(transaction, metadata, task_type, scheduled_at).await
|
|
|
|
}
|
2022-07-31 11:40:24 +00:00
|
|
|
}
|
|
|
|
}
|
2022-08-05 07:06:32 +00:00
|
|
|
|
2022-08-27 15:58:38 +00:00
|
|
|
fn calculate_hash(json: String) -> String {
|
|
|
|
let mut hasher = Sha256::new();
|
|
|
|
hasher.update(json.as_bytes());
|
|
|
|
let result = hasher.finalize();
|
|
|
|
hex::encode(result)
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn find_task_by_uniq_hash_query(
|
2022-07-31 11:40:24 +00:00
|
|
|
transaction: &mut Transaction<'_>,
|
|
|
|
metadata: &serde_json::Value,
|
|
|
|
) -> Option<Task> {
|
2022-08-27 15:58:38 +00:00
|
|
|
let uniq_hash = Self::calculate_hash(metadata.to_string());
|
|
|
|
|
2022-07-31 11:40:24 +00:00
|
|
|
let result = transaction
|
2022-08-27 15:58:38 +00:00
|
|
|
.query_one(FIND_TASK_BY_UNIQ_HASH_QUERY, &[&uniq_hash])
|
2022-07-31 11:40:24 +00:00
|
|
|
.await;
|
|
|
|
|
|
|
|
match result {
|
|
|
|
Ok(row) => Some(Self::row_to_task(row)),
|
|
|
|
Err(_) => None,
|
|
|
|
}
|
|
|
|
}
|
2022-08-05 07:06:32 +00:00
|
|
|
|
2022-08-27 15:58:38 +00:00
|
|
|
fn row_to_task(row: Row) -> Task {
|
2022-07-31 11:40:24 +00:00
|
|
|
let id: Uuid = row.get("id");
|
|
|
|
let metadata: serde_json::Value = row.get("metadata");
|
|
|
|
|
2022-08-27 15:58:38 +00:00
|
|
|
let error_message: Option<String> = row.try_get("error_message").ok();
|
2022-08-05 07:06:32 +00:00
|
|
|
|
2022-08-27 15:58:38 +00:00
|
|
|
let uniq_hash: Option<String> = row.try_get("uniq_hash").ok();
|
2022-07-20 15:26:11 +00:00
|
|
|
let state: FangTaskState = row.get("state");
|
2022-07-19 20:05:09 +00:00
|
|
|
let task_type: String = row.get("task_type");
|
|
|
|
let created_at: DateTime<Utc> = row.get("created_at");
|
|
|
|
let updated_at: DateTime<Utc> = row.get("updated_at");
|
2022-08-27 15:58:38 +00:00
|
|
|
let scheduled_at: DateTime<Utc> = row.get("scheduled_at");
|
2022-07-19 20:05:09 +00:00
|
|
|
|
|
|
|
Task::builder()
|
|
|
|
.id(id)
|
|
|
|
.metadata(metadata)
|
|
|
|
.error_message(error_message)
|
|
|
|
.state(state)
|
2022-08-27 15:58:38 +00:00
|
|
|
.uniq_hash(uniq_hash)
|
2022-07-19 20:05:09 +00:00
|
|
|
.task_type(task_type)
|
|
|
|
.created_at(created_at)
|
|
|
|
.updated_at(updated_at)
|
2022-08-27 15:58:38 +00:00
|
|
|
.scheduled_at(scheduled_at)
|
2022-07-19 20:05:09 +00:00
|
|
|
.build()
|
|
|
|
}
|
2022-07-17 16:22:00 +00:00
|
|
|
}
|
|
|
|
|
2022-07-23 14:24:22 +00:00
|
|
|
#[async_trait]
|
|
|
|
impl<Tls> AsyncQueueable for AsyncQueue<Tls>
|
|
|
|
where
|
|
|
|
Tls: MakeTlsConnect<Socket> + Clone + Send + Sync + 'static,
|
|
|
|
<Tls as MakeTlsConnect<Socket>>::Stream: Send + Sync,
|
|
|
|
<Tls as MakeTlsConnect<Socket>>::TlsConnect: Send,
|
|
|
|
<<Tls as MakeTlsConnect<Socket>>::TlsConnect as TlsConnect<Socket>>::Future: Send,
|
|
|
|
{
|
2022-08-27 15:58:38 +00:00
|
|
|
async fn find_task_by_id(&mut self, id: Uuid) -> Result<Task, AsyncQueueError> {
|
|
|
|
let mut connection = self.pool.as_ref().unwrap().get().await?;
|
|
|
|
let mut transaction = connection.transaction().await?;
|
|
|
|
|
|
|
|
let task = Self::find_task_by_id_query(&mut transaction, id).await?;
|
|
|
|
|
|
|
|
transaction.commit().await?;
|
|
|
|
|
|
|
|
Ok(task)
|
|
|
|
}
|
|
|
|
|
2022-07-23 14:24:22 +00:00
|
|
|
async fn fetch_and_touch_task(
|
|
|
|
&mut self,
|
2022-07-31 11:40:24 +00:00
|
|
|
task_type: Option<String>,
|
2022-07-23 14:24:22 +00:00
|
|
|
) -> Result<Option<Task>, AsyncQueueError> {
|
2022-08-01 19:37:32 +00:00
|
|
|
self.check_if_connection()?;
|
|
|
|
let mut connection = self.pool.as_ref().unwrap().get().await?;
|
2022-07-23 14:24:22 +00:00
|
|
|
let mut transaction = connection.transaction().await?;
|
|
|
|
|
|
|
|
let task = Self::fetch_and_touch_task_query(&mut transaction, task_type).await?;
|
|
|
|
|
|
|
|
transaction.commit().await?;
|
|
|
|
|
|
|
|
Ok(task)
|
|
|
|
}
|
|
|
|
|
2022-07-31 15:15:00 +00:00
|
|
|
async fn insert_task(&mut self, task: &dyn AsyncRunnable) -> Result<Task, AsyncQueueError> {
|
2022-08-01 19:37:32 +00:00
|
|
|
self.check_if_connection()?;
|
|
|
|
let mut connection = self.pool.as_ref().unwrap().get().await?;
|
2022-07-23 14:24:22 +00:00
|
|
|
let mut transaction = connection.transaction().await?;
|
|
|
|
|
2022-07-31 15:15:00 +00:00
|
|
|
let metadata = serde_json::to_value(task)?;
|
|
|
|
|
2022-08-27 15:58:38 +00:00
|
|
|
let task: Task = if !task.uniq() {
|
|
|
|
Self::insert_task_query(&mut transaction, metadata, &task.task_type(), Utc::now())
|
2022-07-31 15:15:00 +00:00
|
|
|
.await?
|
2022-08-27 15:58:38 +00:00
|
|
|
} else {
|
|
|
|
Self::insert_task_if_not_exist_query(
|
|
|
|
&mut transaction,
|
|
|
|
metadata,
|
|
|
|
&task.task_type(),
|
|
|
|
Utc::now(),
|
|
|
|
)
|
|
|
|
.await?
|
2022-07-31 11:40:24 +00:00
|
|
|
};
|
2022-07-23 14:24:22 +00:00
|
|
|
|
|
|
|
transaction.commit().await?;
|
|
|
|
|
|
|
|
Ok(task)
|
|
|
|
}
|
|
|
|
|
2022-08-27 15:58:38 +00:00
|
|
|
async fn schedule_task(&mut self, task: &dyn AsyncRunnable) -> Result<Task, AsyncQueueError> {
|
2022-08-01 19:37:32 +00:00
|
|
|
self.check_if_connection()?;
|
|
|
|
let mut connection = self.pool.as_ref().unwrap().get().await?;
|
2022-07-31 11:40:24 +00:00
|
|
|
let mut transaction = connection.transaction().await?;
|
2022-07-31 15:15:00 +00:00
|
|
|
let metadata = serde_json::to_value(task)?;
|
|
|
|
|
2022-08-27 15:58:38 +00:00
|
|
|
let scheduled_at = match task.cron() {
|
|
|
|
Some(scheduled) => match scheduled {
|
|
|
|
CronPattern(cron_pattern) => {
|
|
|
|
let schedule = Schedule::from_str(&cron_pattern)?;
|
|
|
|
let mut iterator = schedule.upcoming(Utc);
|
|
|
|
iterator
|
|
|
|
.next()
|
|
|
|
.ok_or(AsyncQueueError::CronError(CronError::NoTimestampsError))?
|
|
|
|
}
|
|
|
|
ScheduleOnce(datetime) => datetime,
|
|
|
|
},
|
|
|
|
None => {
|
|
|
|
return Err(AsyncQueueError::CronError(
|
|
|
|
CronError::TaskNotSchedulableError,
|
|
|
|
));
|
|
|
|
}
|
|
|
|
};
|
2022-07-31 11:40:24 +00:00
|
|
|
|
2022-08-27 15:58:38 +00:00
|
|
|
let task: Task = if !task.uniq() {
|
|
|
|
Self::insert_task_query(&mut transaction, metadata, &task.task_type(), scheduled_at)
|
|
|
|
.await?
|
|
|
|
} else {
|
|
|
|
Self::insert_task_if_not_exist_query(
|
|
|
|
&mut transaction,
|
|
|
|
metadata,
|
|
|
|
&task.task_type(),
|
|
|
|
scheduled_at,
|
|
|
|
)
|
|
|
|
.await?
|
|
|
|
};
|
2022-07-31 11:40:24 +00:00
|
|
|
transaction.commit().await?;
|
2022-08-27 15:58:38 +00:00
|
|
|
Ok(task)
|
2022-07-31 11:40:24 +00:00
|
|
|
}
|
|
|
|
|
2022-07-23 14:24:22 +00:00
|
|
|
async fn remove_all_tasks(&mut self) -> Result<u64, AsyncQueueError> {
|
2022-08-01 19:37:32 +00:00
|
|
|
self.check_if_connection()?;
|
|
|
|
let mut connection = self.pool.as_ref().unwrap().get().await?;
|
2022-07-23 14:24:22 +00:00
|
|
|
let mut transaction = connection.transaction().await?;
|
|
|
|
|
|
|
|
let result = Self::remove_all_tasks_query(&mut transaction).await?;
|
|
|
|
|
|
|
|
transaction.commit().await?;
|
|
|
|
|
|
|
|
Ok(result)
|
|
|
|
}
|
|
|
|
|
2022-08-31 23:01:15 +00:00
|
|
|
async fn remove_all_scheduled_tasks(&mut self) -> Result<u64, AsyncQueueError> {
|
|
|
|
self.check_if_connection()?;
|
|
|
|
let mut connection = self.pool.as_ref().unwrap().get().await?;
|
|
|
|
let mut transaction = connection.transaction().await?;
|
|
|
|
|
|
|
|
let result = Self::remove_all_scheduled_tasks_query(&mut transaction).await?;
|
|
|
|
|
|
|
|
transaction.commit().await?;
|
|
|
|
|
|
|
|
Ok(result)
|
|
|
|
}
|
|
|
|
|
2022-07-23 14:24:22 +00:00
|
|
|
async fn remove_task(&mut self, task: Task) -> Result<u64, AsyncQueueError> {
|
2022-08-01 19:37:32 +00:00
|
|
|
self.check_if_connection()?;
|
|
|
|
let mut connection = self.pool.as_ref().unwrap().get().await?;
|
2022-07-23 14:24:22 +00:00
|
|
|
let mut transaction = connection.transaction().await?;
|
|
|
|
|
|
|
|
let result = Self::remove_task_query(&mut transaction, task).await?;
|
|
|
|
|
|
|
|
transaction.commit().await?;
|
|
|
|
|
|
|
|
Ok(result)
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn remove_tasks_type(&mut self, task_type: &str) -> Result<u64, AsyncQueueError> {
|
2022-08-01 19:37:32 +00:00
|
|
|
self.check_if_connection()?;
|
|
|
|
let mut connection = self.pool.as_ref().unwrap().get().await?;
|
2022-07-23 14:24:22 +00:00
|
|
|
let mut transaction = connection.transaction().await?;
|
|
|
|
|
|
|
|
let result = Self::remove_tasks_type_query(&mut transaction, task_type).await?;
|
|
|
|
|
|
|
|
transaction.commit().await?;
|
|
|
|
|
|
|
|
Ok(result)
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn update_task_state(
|
|
|
|
&mut self,
|
|
|
|
task: Task,
|
|
|
|
state: FangTaskState,
|
|
|
|
) -> Result<Task, AsyncQueueError> {
|
2022-08-01 19:37:32 +00:00
|
|
|
self.check_if_connection()?;
|
|
|
|
let mut connection = self.pool.as_ref().unwrap().get().await?;
|
2022-07-23 14:24:22 +00:00
|
|
|
let mut transaction = connection.transaction().await?;
|
|
|
|
|
|
|
|
let task = Self::update_task_state_query(&mut transaction, task, state).await?;
|
|
|
|
transaction.commit().await?;
|
|
|
|
|
|
|
|
Ok(task)
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn fail_task(
|
|
|
|
&mut self,
|
|
|
|
task: Task,
|
|
|
|
error_message: &str,
|
|
|
|
) -> Result<Task, AsyncQueueError> {
|
2022-08-01 19:37:32 +00:00
|
|
|
self.check_if_connection()?;
|
|
|
|
let mut connection = self.pool.as_ref().unwrap().get().await?;
|
2022-07-23 14:24:22 +00:00
|
|
|
let mut transaction = connection.transaction().await?;
|
|
|
|
|
|
|
|
let task = Self::fail_task_query(&mut transaction, task, error_message).await?;
|
|
|
|
transaction.commit().await?;
|
|
|
|
|
|
|
|
Ok(task)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-07-17 16:22:00 +00:00
|
|
|
#[cfg(test)]
|
|
|
|
mod async_queue_tests {
|
2022-07-27 17:05:05 +00:00
|
|
|
use super::AsyncQueueTest;
|
2022-07-23 14:24:22 +00:00
|
|
|
use super::AsyncQueueable;
|
2022-07-20 15:26:11 +00:00
|
|
|
use super::FangTaskState;
|
2022-07-23 14:24:22 +00:00
|
|
|
use super::Task;
|
2022-07-17 16:22:00 +00:00
|
|
|
use crate::asynk::AsyncRunnable;
|
2022-08-31 17:45:13 +00:00
|
|
|
use crate::FangError;
|
2022-08-29 16:59:22 +00:00
|
|
|
use crate::Scheduled;
|
2022-07-17 16:22:00 +00:00
|
|
|
use async_trait::async_trait;
|
|
|
|
use bb8_postgres::bb8::Pool;
|
|
|
|
use bb8_postgres::tokio_postgres::NoTls;
|
|
|
|
use bb8_postgres::PostgresConnectionManager;
|
2022-08-27 15:58:38 +00:00
|
|
|
use chrono::DateTime;
|
|
|
|
use chrono::Duration;
|
|
|
|
use chrono::SubsecRound;
|
|
|
|
use chrono::Utc;
|
2022-07-17 16:22:00 +00:00
|
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
|
|
|
|
#[derive(Serialize, Deserialize)]
|
2022-07-19 13:49:43 +00:00
|
|
|
struct AsyncTask {
|
2022-07-17 16:22:00 +00:00
|
|
|
pub number: u16,
|
|
|
|
}
|
|
|
|
|
|
|
|
#[typetag::serde]
|
2022-07-31 13:32:37 +00:00
|
|
|
#[async_trait]
|
2022-07-19 13:49:43 +00:00
|
|
|
impl AsyncRunnable for AsyncTask {
|
2022-08-31 17:45:13 +00:00
|
|
|
async fn run(&self, _queueable: &mut dyn AsyncQueueable) -> Result<(), FangError> {
|
2022-07-17 16:22:00 +00:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-08-27 15:58:38 +00:00
|
|
|
#[derive(Serialize, Deserialize)]
|
|
|
|
struct AsyncTaskSchedule {
|
|
|
|
pub number: u16,
|
|
|
|
pub datetime: String,
|
|
|
|
}
|
|
|
|
|
|
|
|
#[typetag::serde]
|
|
|
|
#[async_trait]
|
|
|
|
impl AsyncRunnable for AsyncTaskSchedule {
|
2022-08-31 17:45:13 +00:00
|
|
|
async fn run(&self, _queueable: &mut dyn AsyncQueueable) -> Result<(), FangError> {
|
2022-08-27 15:58:38 +00:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
fn cron(&self) -> Option<Scheduled> {
|
|
|
|
let datetime = self.datetime.parse::<DateTime<Utc>>().ok()?;
|
|
|
|
Some(Scheduled::ScheduleOnce(datetime))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-07-17 16:22:00 +00:00
|
|
|
#[tokio::test]
|
|
|
|
async fn insert_task_creates_new_task() {
|
2022-07-17 19:34:55 +00:00
|
|
|
let pool = pool().await;
|
|
|
|
let mut connection = pool.get().await.unwrap();
|
2022-07-27 17:05:05 +00:00
|
|
|
let transaction = connection.transaction().await.unwrap();
|
2022-07-17 16:22:00 +00:00
|
|
|
|
2022-07-31 11:40:24 +00:00
|
|
|
let mut test = AsyncQueueTest::builder().transaction(transaction).build();
|
2022-07-23 14:24:22 +00:00
|
|
|
|
2022-07-27 17:05:05 +00:00
|
|
|
let task = insert_task(&mut test, &AsyncTask { number: 1 }).await;
|
2022-07-23 14:24:22 +00:00
|
|
|
|
2022-07-20 14:27:01 +00:00
|
|
|
let metadata = task.metadata.as_object().unwrap();
|
|
|
|
let number = metadata["number"].as_u64();
|
|
|
|
let type_task = metadata["type"].as_str();
|
2022-07-17 16:22:00 +00:00
|
|
|
|
2022-07-20 14:27:01 +00:00
|
|
|
assert_eq!(Some(1), number);
|
|
|
|
assert_eq!(Some("AsyncTask"), type_task);
|
2022-07-27 17:05:05 +00:00
|
|
|
test.transaction.rollback().await.unwrap();
|
2022-07-18 10:44:05 +00:00
|
|
|
}
|
2022-07-23 14:24:22 +00:00
|
|
|
|
|
|
|
#[tokio::test]
|
|
|
|
async fn update_task_state_test() {
|
|
|
|
let pool = pool().await;
|
|
|
|
let mut connection = pool.get().await.unwrap();
|
2022-07-27 17:05:05 +00:00
|
|
|
let transaction = connection.transaction().await.unwrap();
|
|
|
|
|
2022-07-31 11:40:24 +00:00
|
|
|
let mut test = AsyncQueueTest::builder().transaction(transaction).build();
|
2022-07-23 14:24:22 +00:00
|
|
|
|
2022-07-27 17:05:05 +00:00
|
|
|
let task = insert_task(&mut test, &AsyncTask { number: 1 }).await;
|
2022-07-23 14:24:22 +00:00
|
|
|
|
|
|
|
let metadata = task.metadata.as_object().unwrap();
|
|
|
|
let number = metadata["number"].as_u64();
|
|
|
|
let type_task = metadata["type"].as_str();
|
|
|
|
let id = task.id;
|
|
|
|
|
|
|
|
assert_eq!(Some(1), number);
|
|
|
|
assert_eq!(Some("AsyncTask"), type_task);
|
|
|
|
|
2022-07-27 17:05:05 +00:00
|
|
|
let finished_task = test
|
|
|
|
.update_task_state(task, FangTaskState::Finished)
|
|
|
|
.await
|
|
|
|
.unwrap();
|
2022-07-23 14:24:22 +00:00
|
|
|
|
|
|
|
assert_eq!(id, finished_task.id);
|
|
|
|
assert_eq!(FangTaskState::Finished, finished_task.state);
|
|
|
|
|
2022-07-27 17:05:05 +00:00
|
|
|
test.transaction.rollback().await.unwrap();
|
2022-07-23 14:24:22 +00:00
|
|
|
}
|
|
|
|
|
2022-07-20 15:26:11 +00:00
|
|
|
#[tokio::test]
|
|
|
|
async fn failed_task_query_test() {
|
|
|
|
let pool = pool().await;
|
|
|
|
let mut connection = pool.get().await.unwrap();
|
2022-07-27 17:05:05 +00:00
|
|
|
let transaction = connection.transaction().await.unwrap();
|
|
|
|
|
2022-07-31 11:40:24 +00:00
|
|
|
let mut test = AsyncQueueTest::builder().transaction(transaction).build();
|
2022-07-20 15:26:11 +00:00
|
|
|
|
2022-07-27 17:05:05 +00:00
|
|
|
let task = insert_task(&mut test, &AsyncTask { number: 1 }).await;
|
2022-07-23 14:24:22 +00:00
|
|
|
|
2022-07-20 15:26:11 +00:00
|
|
|
let metadata = task.metadata.as_object().unwrap();
|
|
|
|
let number = metadata["number"].as_u64();
|
|
|
|
let type_task = metadata["type"].as_str();
|
|
|
|
let id = task.id;
|
2022-07-23 14:24:22 +00:00
|
|
|
|
2022-07-20 15:26:11 +00:00
|
|
|
assert_eq!(Some(1), number);
|
|
|
|
assert_eq!(Some("AsyncTask"), type_task);
|
2022-07-23 14:24:22 +00:00
|
|
|
|
2022-07-27 17:05:05 +00:00
|
|
|
let failed_task = test.fail_task(task, "Some error").await.unwrap();
|
2022-07-23 14:24:22 +00:00
|
|
|
|
2022-07-20 15:26:11 +00:00
|
|
|
assert_eq!(id, failed_task.id);
|
|
|
|
assert_eq!(Some("Some error"), failed_task.error_message.as_deref());
|
|
|
|
assert_eq!(FangTaskState::Failed, failed_task.state);
|
2022-07-23 14:24:22 +00:00
|
|
|
|
2022-07-27 17:05:05 +00:00
|
|
|
test.transaction.rollback().await.unwrap();
|
2022-07-20 15:26:11 +00:00
|
|
|
}
|
2022-07-18 10:44:05 +00:00
|
|
|
|
2022-07-20 10:01:33 +00:00
|
|
|
#[tokio::test]
|
|
|
|
async fn remove_all_tasks_test() {
|
|
|
|
let pool = pool().await;
|
|
|
|
let mut connection = pool.get().await.unwrap();
|
2022-07-27 17:05:05 +00:00
|
|
|
let transaction = connection.transaction().await.unwrap();
|
2022-07-18 10:44:05 +00:00
|
|
|
|
2022-07-31 11:40:24 +00:00
|
|
|
let mut test = AsyncQueueTest::builder().transaction(transaction).build();
|
2022-07-27 17:05:05 +00:00
|
|
|
|
|
|
|
let task = insert_task(&mut test, &AsyncTask { number: 1 }).await;
|
2022-07-19 20:05:09 +00:00
|
|
|
|
2022-07-20 14:27:01 +00:00
|
|
|
let metadata = task.metadata.as_object().unwrap();
|
|
|
|
let number = metadata["number"].as_u64();
|
|
|
|
let type_task = metadata["type"].as_str();
|
|
|
|
|
|
|
|
assert_eq!(Some(1), number);
|
|
|
|
assert_eq!(Some("AsyncTask"), type_task);
|
|
|
|
|
2022-07-27 17:05:05 +00:00
|
|
|
let task = insert_task(&mut test, &AsyncTask { number: 2 }).await;
|
2022-07-23 14:24:22 +00:00
|
|
|
|
2022-07-20 14:27:01 +00:00
|
|
|
let metadata = task.metadata.as_object().unwrap();
|
|
|
|
let number = metadata["number"].as_u64();
|
|
|
|
let type_task = metadata["type"].as_str();
|
|
|
|
|
|
|
|
assert_eq!(Some(2), number);
|
|
|
|
assert_eq!(Some("AsyncTask"), type_task);
|
2022-07-19 20:05:09 +00:00
|
|
|
|
2022-07-27 17:05:05 +00:00
|
|
|
let result = test.remove_all_tasks().await.unwrap();
|
2022-07-20 10:01:33 +00:00
|
|
|
assert_eq!(2, result);
|
2022-07-19 20:05:09 +00:00
|
|
|
|
2022-07-27 17:05:05 +00:00
|
|
|
test.transaction.rollback().await.unwrap();
|
2022-07-20 10:01:33 +00:00
|
|
|
}
|
2022-07-19 13:49:43 +00:00
|
|
|
|
2022-08-27 15:58:38 +00:00
|
|
|
#[tokio::test]
|
|
|
|
async fn schedule_task_test() {
|
|
|
|
let pool = pool().await;
|
|
|
|
let mut connection = pool.get().await.unwrap();
|
|
|
|
let transaction = connection.transaction().await.unwrap();
|
|
|
|
|
|
|
|
let mut test = AsyncQueueTest::builder().transaction(transaction).build();
|
|
|
|
|
|
|
|
let datetime = (Utc::now() + Duration::seconds(7)).round_subsecs(0);
|
|
|
|
|
|
|
|
let task = &AsyncTaskSchedule {
|
|
|
|
number: 1,
|
|
|
|
datetime: datetime.to_string(),
|
|
|
|
};
|
|
|
|
|
|
|
|
let task = test.schedule_task(task).await.unwrap();
|
|
|
|
|
|
|
|
let metadata = task.metadata.as_object().unwrap();
|
|
|
|
let number = metadata["number"].as_u64();
|
|
|
|
let type_task = metadata["type"].as_str();
|
|
|
|
|
|
|
|
assert_eq!(Some(1), number);
|
|
|
|
assert_eq!(Some("AsyncTaskSchedule"), type_task);
|
|
|
|
assert_eq!(task.scheduled_at, datetime);
|
|
|
|
}
|
|
|
|
|
2022-08-31 23:01:15 +00:00
|
|
|
#[tokio::test]
|
|
|
|
async fn remove_all_scheduled_tasks_test() {
|
|
|
|
let pool = pool().await;
|
|
|
|
let mut connection = pool.get().await.unwrap();
|
|
|
|
let transaction = connection.transaction().await.unwrap();
|
|
|
|
|
|
|
|
let mut test = AsyncQueueTest::builder().transaction(transaction).build();
|
|
|
|
|
|
|
|
let datetime = (Utc::now() + Duration::seconds(7)).round_subsecs(0);
|
|
|
|
|
|
|
|
let task1 = &AsyncTaskSchedule {
|
|
|
|
number: 1,
|
|
|
|
datetime: datetime.to_string(),
|
|
|
|
};
|
|
|
|
|
|
|
|
let task2 = &AsyncTaskSchedule {
|
|
|
|
number: 2,
|
|
|
|
datetime: datetime.to_string(),
|
|
|
|
};
|
|
|
|
|
|
|
|
test.schedule_task(task1).await.unwrap();
|
|
|
|
test.schedule_task(task2).await.unwrap();
|
|
|
|
|
|
|
|
let number = test.remove_all_scheduled_tasks().await.unwrap();
|
|
|
|
|
|
|
|
assert_eq!(2, number);
|
|
|
|
}
|
|
|
|
|
2022-07-19 13:49:43 +00:00
|
|
|
#[tokio::test]
|
2022-07-19 20:05:09 +00:00
|
|
|
async fn fetch_and_touch_test() {
|
2022-07-19 13:49:43 +00:00
|
|
|
let pool = pool().await;
|
|
|
|
let mut connection = pool.get().await.unwrap();
|
2022-07-27 17:05:05 +00:00
|
|
|
let transaction = connection.transaction().await.unwrap();
|
2022-07-19 13:49:43 +00:00
|
|
|
|
2022-07-31 11:40:24 +00:00
|
|
|
let mut test = AsyncQueueTest::builder().transaction(transaction).build();
|
2022-07-27 17:05:05 +00:00
|
|
|
|
|
|
|
let task = insert_task(&mut test, &AsyncTask { number: 1 }).await;
|
2022-07-23 14:24:22 +00:00
|
|
|
|
2022-07-20 14:27:01 +00:00
|
|
|
let metadata = task.metadata.as_object().unwrap();
|
|
|
|
let number = metadata["number"].as_u64();
|
|
|
|
let type_task = metadata["type"].as_str();
|
|
|
|
|
|
|
|
assert_eq!(Some(1), number);
|
|
|
|
assert_eq!(Some("AsyncTask"), type_task);
|
2022-07-19 20:05:09 +00:00
|
|
|
|
2022-07-27 17:05:05 +00:00
|
|
|
let task = insert_task(&mut test, &AsyncTask { number: 2 }).await;
|
2022-07-23 14:24:22 +00:00
|
|
|
|
2022-07-20 14:27:01 +00:00
|
|
|
let metadata = task.metadata.as_object().unwrap();
|
|
|
|
let number = metadata["number"].as_u64();
|
|
|
|
let type_task = metadata["type"].as_str();
|
|
|
|
|
|
|
|
assert_eq!(Some(2), number);
|
|
|
|
assert_eq!(Some("AsyncTask"), type_task);
|
2022-07-19 20:05:09 +00:00
|
|
|
|
2022-07-31 11:40:24 +00:00
|
|
|
let task = test.fetch_and_touch_task(None).await.unwrap().unwrap();
|
2022-07-23 14:24:22 +00:00
|
|
|
|
2022-07-19 13:49:43 +00:00
|
|
|
let metadata = task.metadata.as_object().unwrap();
|
|
|
|
let number = metadata["number"].as_u64();
|
|
|
|
let type_task = metadata["type"].as_str();
|
2022-07-19 20:05:09 +00:00
|
|
|
|
2022-07-19 13:49:43 +00:00
|
|
|
assert_eq!(Some(1), number);
|
|
|
|
assert_eq!(Some("AsyncTask"), type_task);
|
2022-07-19 20:05:09 +00:00
|
|
|
|
2022-07-31 11:40:24 +00:00
|
|
|
let task = test.fetch_and_touch_task(None).await.unwrap().unwrap();
|
2022-07-19 13:49:43 +00:00
|
|
|
let metadata = task.metadata.as_object().unwrap();
|
|
|
|
let number = metadata["number"].as_u64();
|
|
|
|
let type_task = metadata["type"].as_str();
|
2022-07-19 20:05:09 +00:00
|
|
|
|
2022-07-19 13:49:43 +00:00
|
|
|
assert_eq!(Some(2), number);
|
|
|
|
assert_eq!(Some("AsyncTask"), type_task);
|
2022-07-18 10:44:05 +00:00
|
|
|
|
2022-07-27 17:05:05 +00:00
|
|
|
test.transaction.rollback().await.unwrap();
|
2022-07-17 16:22:00 +00:00
|
|
|
}
|
2022-07-19 20:05:09 +00:00
|
|
|
|
2022-07-20 10:01:33 +00:00
|
|
|
#[tokio::test]
|
|
|
|
async fn remove_tasks_type_test() {
|
|
|
|
let pool = pool().await;
|
|
|
|
let mut connection = pool.get().await.unwrap();
|
2022-07-27 17:05:05 +00:00
|
|
|
let transaction = connection.transaction().await.unwrap();
|
|
|
|
|
2022-07-31 11:40:24 +00:00
|
|
|
let mut test = AsyncQueueTest::builder().transaction(transaction).build();
|
2022-07-20 10:01:33 +00:00
|
|
|
|
2022-07-27 17:05:05 +00:00
|
|
|
let task = insert_task(&mut test, &AsyncTask { number: 1 }).await;
|
2022-07-23 14:24:22 +00:00
|
|
|
|
2022-07-20 14:27:01 +00:00
|
|
|
let metadata = task.metadata.as_object().unwrap();
|
|
|
|
let number = metadata["number"].as_u64();
|
|
|
|
let type_task = metadata["type"].as_str();
|
|
|
|
|
|
|
|
assert_eq!(Some(1), number);
|
|
|
|
assert_eq!(Some("AsyncTask"), type_task);
|
2022-07-20 10:01:33 +00:00
|
|
|
|
2022-07-27 17:05:05 +00:00
|
|
|
let task = insert_task(&mut test, &AsyncTask { number: 2 }).await;
|
2022-07-23 14:24:22 +00:00
|
|
|
|
2022-07-20 14:27:01 +00:00
|
|
|
let metadata = task.metadata.as_object().unwrap();
|
|
|
|
let number = metadata["number"].as_u64();
|
|
|
|
let type_task = metadata["type"].as_str();
|
|
|
|
|
|
|
|
assert_eq!(Some(2), number);
|
|
|
|
assert_eq!(Some("AsyncTask"), type_task);
|
2022-07-19 20:05:09 +00:00
|
|
|
|
2022-07-27 17:05:05 +00:00
|
|
|
let result = test.remove_tasks_type("mytype").await.unwrap();
|
2022-07-20 10:01:33 +00:00
|
|
|
assert_eq!(0, result);
|
2022-07-19 20:05:09 +00:00
|
|
|
|
2022-07-27 17:05:05 +00:00
|
|
|
let result = test.remove_tasks_type("common").await.unwrap();
|
2022-07-20 10:01:33 +00:00
|
|
|
assert_eq!(2, result);
|
2022-07-19 20:05:09 +00:00
|
|
|
|
2022-07-27 17:05:05 +00:00
|
|
|
test.transaction.rollback().await.unwrap();
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn insert_task(test: &mut AsyncQueueTest<'_>, task: &dyn AsyncRunnable) -> Task {
|
2022-07-31 15:15:00 +00:00
|
|
|
test.insert_task(task).await.unwrap()
|
2022-07-20 10:01:33 +00:00
|
|
|
}
|
2022-07-17 16:22:00 +00:00
|
|
|
|
2022-07-17 19:34:55 +00:00
|
|
|
async fn pool() -> Pool<PostgresConnectionManager<NoTls>> {
|
2022-07-17 16:22:00 +00:00
|
|
|
let pg_mgr = PostgresConnectionManager::new_from_stringlike(
|
|
|
|
"postgres://postgres:postgres@localhost/fang",
|
|
|
|
NoTls,
|
|
|
|
)
|
|
|
|
.unwrap();
|
|
|
|
|
2022-07-17 19:34:55 +00:00
|
|
|
Pool::builder().build(pg_mgr).await.unwrap()
|
2022-07-17 07:13:45 +00:00
|
|
|
}
|
|
|
|
}
|