2022-07-17 16:22:00 +00:00
|
|
|
use crate::asynk::AsyncRunnable;
|
|
|
|
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-17 16:22:00 +00:00
|
|
|
use bb8_postgres::tokio_postgres::tls::MakeTlsConnect;
|
|
|
|
use bb8_postgres::tokio_postgres::tls::TlsConnect;
|
|
|
|
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-07-19 13:49:43 +00:00
|
|
|
use postgres_types::{FromSql, ToSql};
|
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-07-19 20:05:09 +00:00
|
|
|
const INSERT_TASK_QUERY: &str = include_str!("queries/insert_task.sql");
|
|
|
|
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");
|
|
|
|
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");
|
|
|
|
|
|
|
|
const DEFAULT_TASK_TYPE: &str = "common";
|
|
|
|
|
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,
|
|
|
|
}
|
|
|
|
impl Default for FangTaskState {
|
|
|
|
fn default() -> Self {
|
|
|
|
FangTaskState::New
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#[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))]
|
|
|
|
pub created_at: DateTime<Utc>,
|
|
|
|
#[builder(setter(into))]
|
|
|
|
pub updated_at: DateTime<Utc>,
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(TypedBuilder, Debug, Eq, PartialEq, Clone)]
|
|
|
|
pub struct PeriodicTask {
|
|
|
|
#[builder(setter(into))]
|
|
|
|
pub id: Uuid,
|
|
|
|
#[builder(setter(into))]
|
|
|
|
pub metadata: serde_json::Value,
|
|
|
|
#[builder(setter(into))]
|
|
|
|
pub period_in_seconds: i32,
|
|
|
|
#[builder(setter(into))]
|
|
|
|
pub scheduled_at: Option<DateTime<Utc>>,
|
|
|
|
#[builder(setter(into))]
|
|
|
|
pub created_at: DateTime<Utc>,
|
|
|
|
#[builder(setter(into))]
|
|
|
|
pub updated_at: DateTime<Utc>,
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(TypedBuilder, Debug, Eq, PartialEq, Clone)]
|
|
|
|
pub struct NewTask {
|
|
|
|
#[builder(setter(into))]
|
|
|
|
pub metadata: serde_json::Value,
|
|
|
|
#[builder(setter(into))]
|
|
|
|
pub task_type: String,
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(TypedBuilder, Debug, Eq, PartialEq, Clone)]
|
|
|
|
pub struct NewPeriodicTask {
|
|
|
|
#[builder(setter(into))]
|
|
|
|
pub metadata: serde_json::Value,
|
|
|
|
#[builder(setter(into))]
|
|
|
|
pub period_in_seconds: i32,
|
|
|
|
}
|
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),
|
|
|
|
#[error("returned invalid result (expected {expected:?}, found {found:?})")]
|
|
|
|
ResultError { expected: u64, found: u64 },
|
2022-07-17 07:13:45 +00:00
|
|
|
}
|
|
|
|
|
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-07-19 20:05:09 +00:00
|
|
|
pool: Pool<PostgresConnectionManager<Tls>>,
|
2022-07-17 16:22:00 +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,
|
|
|
|
{
|
|
|
|
pub fn new(pool: Pool<PostgresConnectionManager<Tls>>) -> Self {
|
2022-07-19 20:05:09 +00:00
|
|
|
AsyncQueue { pool }
|
2022-07-17 16:22:00 +00:00
|
|
|
}
|
|
|
|
|
2022-07-19 20:05:09 +00:00
|
|
|
pub async fn fetch_and_touch_task(
|
2022-07-19 13:49:43 +00:00
|
|
|
&mut self,
|
|
|
|
task_type: &Option<String>,
|
|
|
|
) -> Result<Task, AsyncQueueError> {
|
2022-07-19 20:05:09 +00:00
|
|
|
let mut connection = self.pool.get().await?;
|
|
|
|
let mut transaction = connection.transaction().await?;
|
|
|
|
|
|
|
|
let task = Self::fetch_and_touch_task_query(&mut transaction, task_type).await?;
|
|
|
|
|
|
|
|
transaction.commit().await?;
|
|
|
|
|
2022-07-19 13:49:43 +00:00
|
|
|
Ok(task)
|
|
|
|
}
|
2022-07-19 20:05:09 +00:00
|
|
|
|
2022-07-19 13:49:43 +00:00
|
|
|
pub async fn get_row(
|
|
|
|
&mut self,
|
|
|
|
query: &str,
|
|
|
|
params: &[&(dyn ToSql + Sync)],
|
|
|
|
) -> Result<Row, AsyncQueueError> {
|
2022-07-19 20:05:09 +00:00
|
|
|
let connection = self.pool.get().await?;
|
|
|
|
|
|
|
|
let row = connection.query_one(query, params).await?;
|
|
|
|
|
2022-07-19 13:49:43 +00:00
|
|
|
Ok(row)
|
|
|
|
}
|
2022-07-19 20:05:09 +00:00
|
|
|
|
2022-07-17 16:22:00 +00:00
|
|
|
pub async fn insert_task(&mut self, task: &dyn AsyncRunnable) -> Result<u64, AsyncQueueError> {
|
2022-07-19 20:05:09 +00:00
|
|
|
let mut connection = self.pool.get().await?;
|
|
|
|
let mut transaction = connection.transaction().await?;
|
2022-07-17 16:22:00 +00:00
|
|
|
|
2022-07-19 20:05:09 +00:00
|
|
|
Self::insert_task_query(&mut transaction, task).await
|
2022-07-18 10:44:05 +00:00
|
|
|
}
|
2022-07-19 20:05:09 +00:00
|
|
|
|
2022-07-18 10:44:05 +00:00
|
|
|
pub async fn remove_all_tasks(&mut self) -> Result<u64, AsyncQueueError> {
|
|
|
|
self.execute(REMOVE_ALL_TASK_QUERY, &[], None).await
|
|
|
|
}
|
2022-07-19 20:05:09 +00:00
|
|
|
|
2022-07-18 10:44:05 +00:00
|
|
|
pub async fn remove_task(&mut self, task: &Task) -> Result<u64, AsyncQueueError> {
|
|
|
|
self.execute(REMOVE_TASK_QUERY, &[&task.id], Some(1)).await
|
|
|
|
}
|
2022-07-19 20:05:09 +00:00
|
|
|
|
2022-07-18 10:44:05 +00:00
|
|
|
pub async fn remove_tasks_type(&mut self, task_type: &str) -> Result<u64, AsyncQueueError> {
|
|
|
|
self.execute(REMOVE_TASKS_TYPE_QUERY, &[&task_type], None)
|
|
|
|
.await
|
|
|
|
}
|
2022-07-19 20:05:09 +00:00
|
|
|
|
2022-07-18 10:44:05 +00:00
|
|
|
pub async fn fail_task(&mut self, task: &Task) -> Result<u64, AsyncQueueError> {
|
|
|
|
let updated_at = Utc::now();
|
|
|
|
self.execute(
|
|
|
|
FAIL_TASK_QUERY,
|
2022-07-19 13:49:43 +00:00
|
|
|
&[
|
|
|
|
&FangTaskState::Failed,
|
|
|
|
&task.error_message,
|
|
|
|
&updated_at,
|
|
|
|
&task.id,
|
|
|
|
],
|
2022-07-18 10:44:05 +00:00
|
|
|
Some(1),
|
|
|
|
)
|
|
|
|
.await
|
|
|
|
}
|
2022-07-17 16:22:00 +00:00
|
|
|
|
2022-07-18 10:44:05 +00:00
|
|
|
async fn execute(
|
2022-07-17 16:22:00 +00:00
|
|
|
&mut self,
|
|
|
|
query: &str,
|
|
|
|
params: &[&(dyn ToSql + Sync)],
|
2022-07-18 10:44:05 +00:00
|
|
|
expected_result_count: Option<u64>,
|
2022-07-17 16:22:00 +00:00
|
|
|
) -> Result<u64, AsyncQueueError> {
|
2022-07-19 20:05:09 +00:00
|
|
|
let connection = self.pool.get().await?;
|
|
|
|
|
|
|
|
let result = connection.execute(query, params).await?;
|
|
|
|
if let Some(expected_result) = expected_result_count {
|
|
|
|
if result != expected_result {
|
|
|
|
return Err(AsyncQueueError::ResultError {
|
|
|
|
expected: expected_result,
|
|
|
|
found: result,
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Ok(result)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub async fn fetch_and_touch_task_query(
|
|
|
|
transaction: &mut Transaction<'_>,
|
|
|
|
task_type: &Option<String>,
|
|
|
|
) -> Result<Task, AsyncQueueError> {
|
|
|
|
let mut task = match task_type {
|
|
|
|
None => Self::get_task_type(transaction, DEFAULT_TASK_TYPE).await?,
|
|
|
|
Some(task_type_str) => Self::get_task_type(transaction, task_type_str).await?,
|
2022-07-17 16:22:00 +00:00
|
|
|
};
|
2022-07-19 20:05:09 +00:00
|
|
|
|
|
|
|
Self::update_task_state(transaction, &task, FangTaskState::InProgress).await?;
|
|
|
|
|
|
|
|
task.state = FangTaskState::InProgress;
|
|
|
|
|
|
|
|
Ok(task)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub async fn get_task_type(
|
|
|
|
transaction: &mut Transaction<'_>,
|
|
|
|
task_type: &str,
|
|
|
|
) -> Result<Task, AsyncQueueError> {
|
|
|
|
let row: Row = transaction
|
|
|
|
.query_one(FETCH_TASK_TYPE_QUERY, &[&task_type])
|
|
|
|
.await?;
|
|
|
|
|
|
|
|
let task = Self::row_to_task(row);
|
|
|
|
|
|
|
|
Ok(task)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub async fn update_task_state(
|
|
|
|
transaction: &mut Transaction<'_>,
|
|
|
|
task: &Task,
|
|
|
|
state: FangTaskState,
|
|
|
|
) -> Result<u64, AsyncQueueError> {
|
|
|
|
let updated_at = Utc::now();
|
|
|
|
|
|
|
|
Self::execute_query(
|
|
|
|
transaction,
|
|
|
|
UPDATE_TASK_STATE_QUERY,
|
|
|
|
&[&state, &updated_at, &task.id],
|
|
|
|
Some(1),
|
|
|
|
)
|
|
|
|
.await
|
|
|
|
}
|
|
|
|
|
|
|
|
pub async fn insert_task_query(
|
|
|
|
transaction: &mut Transaction<'_>,
|
|
|
|
task: &dyn AsyncRunnable,
|
|
|
|
) -> Result<u64, AsyncQueueError> {
|
|
|
|
let metadata = serde_json::to_value(task).unwrap();
|
|
|
|
let task_type = task.task_type();
|
|
|
|
|
|
|
|
Self::execute_query(
|
|
|
|
transaction,
|
|
|
|
INSERT_TASK_QUERY,
|
|
|
|
&[&metadata, &task_type],
|
|
|
|
Some(1),
|
|
|
|
)
|
|
|
|
.await
|
|
|
|
}
|
|
|
|
|
|
|
|
pub async fn execute_query(
|
|
|
|
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
|
|
|
|
|
|
|
fn row_to_task(row: Row) -> Task {
|
|
|
|
let id: Uuid = row.get("id");
|
|
|
|
let metadata: serde_json::Value = row.get("metadata");
|
|
|
|
let error_message: Option<String> = match row.try_get("error_message") {
|
|
|
|
Ok(error_message) => Some(error_message),
|
|
|
|
Err(_) => None,
|
|
|
|
};
|
|
|
|
let state: FangTaskState = FangTaskState::New;
|
|
|
|
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");
|
|
|
|
|
|
|
|
Task::builder()
|
|
|
|
.id(id)
|
|
|
|
.metadata(metadata)
|
|
|
|
.error_message(error_message)
|
|
|
|
.state(state)
|
|
|
|
.task_type(task_type)
|
|
|
|
.created_at(created_at)
|
|
|
|
.updated_at(updated_at)
|
|
|
|
.build()
|
|
|
|
}
|
2022-07-17 16:22:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod async_queue_tests {
|
|
|
|
use super::AsyncQueue;
|
|
|
|
use crate::asynk::AsyncRunnable;
|
|
|
|
use crate::asynk::Error;
|
|
|
|
use async_trait::async_trait;
|
|
|
|
use bb8_postgres::bb8::Pool;
|
|
|
|
use bb8_postgres::tokio_postgres::Client;
|
|
|
|
use bb8_postgres::tokio_postgres::NoTls;
|
|
|
|
use bb8_postgres::PostgresConnectionManager;
|
|
|
|
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]
|
|
|
|
#[async_trait]
|
2022-07-19 13:49:43 +00:00
|
|
|
impl AsyncRunnable for AsyncTask {
|
2022-07-17 16:22:00 +00:00
|
|
|
async fn run(&self, _connection: &Client) -> Result<(), Error> {
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[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-19 20:05:09 +00:00
|
|
|
let mut transaction = connection.transaction().await.unwrap();
|
2022-07-17 16:22:00 +00:00
|
|
|
|
2022-07-19 20:05:09 +00:00
|
|
|
let result =
|
|
|
|
AsyncQueue::<NoTls>::insert_task_query(&mut transaction, &AsyncTask { number: 1 })
|
|
|
|
.await
|
|
|
|
.unwrap();
|
2022-07-17 16:22:00 +00:00
|
|
|
|
|
|
|
assert_eq!(1, result);
|
2022-07-19 20:05:09 +00:00
|
|
|
transaction.rollback().await.unwrap();
|
2022-07-18 10:44:05 +00:00
|
|
|
}
|
|
|
|
|
2022-07-19 20:05:09 +00:00
|
|
|
// #[tokio::test]
|
|
|
|
// async fn remove_all_tasks_test() {
|
|
|
|
// let pool = pool().await;
|
|
|
|
// let mut connection = pool.get().await.unwrap();
|
|
|
|
// let transaction = connection.transaction().await.unwrap();
|
|
|
|
// let mut queue = AsyncQueue::<NoTls>::new_with_transaction(transaction);
|
2022-07-18 10:44:05 +00:00
|
|
|
|
2022-07-19 20:05:09 +00:00
|
|
|
// let result = queue.insert_task(&AsyncTask { number: 1 }).await.unwrap();
|
|
|
|
// assert_eq!(1, result);
|
|
|
|
|
|
|
|
// let result = queue.insert_task(&AsyncTask { number: 2 }).await.unwrap();
|
|
|
|
// assert_eq!(1, result);
|
|
|
|
|
|
|
|
// let result = queue.remove_all_tasks().await.unwrap();
|
|
|
|
// assert_eq!(2, result);
|
|
|
|
|
|
|
|
// queue.rollback().await.unwrap();
|
|
|
|
// }
|
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-19 20:05:09 +00:00
|
|
|
let mut transaction = connection.transaction().await.unwrap();
|
2022-07-19 13:49:43 +00:00
|
|
|
|
2022-07-19 20:05:09 +00:00
|
|
|
let result =
|
|
|
|
AsyncQueue::<NoTls>::insert_task_query(&mut transaction, &AsyncTask { number: 1 })
|
|
|
|
.await
|
|
|
|
.unwrap();
|
2022-07-19 13:49:43 +00:00
|
|
|
assert_eq!(1, result);
|
2022-07-19 20:05:09 +00:00
|
|
|
|
|
|
|
let result =
|
|
|
|
AsyncQueue::<NoTls>::insert_task_query(&mut transaction, &AsyncTask { number: 2 })
|
|
|
|
.await
|
|
|
|
.unwrap();
|
2022-07-19 13:49:43 +00:00
|
|
|
assert_eq!(1, result);
|
2022-07-19 20:05:09 +00:00
|
|
|
|
|
|
|
let task = AsyncQueue::<NoTls>::fetch_and_touch_task_query(&mut transaction, &None)
|
|
|
|
.await
|
|
|
|
.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(1), number);
|
|
|
|
assert_eq!(Some("AsyncTask"), type_task);
|
2022-07-19 20:05:09 +00:00
|
|
|
|
|
|
|
let task = AsyncQueue::<NoTls>::fetch_and_touch_task_query(&mut transaction, &None)
|
|
|
|
.await
|
|
|
|
.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-19 20:05:09 +00:00
|
|
|
transaction.rollback().await.unwrap();
|
2022-07-17 16:22:00 +00:00
|
|
|
}
|
2022-07-19 20:05:09 +00:00
|
|
|
// #[tokio::test]
|
|
|
|
// async fn remove_tasks_type_test() {
|
|
|
|
// let pool = pool().await;
|
|
|
|
// let mut connection = pool.get().await.unwrap();
|
|
|
|
// let transaction = connection.transaction().await.unwrap();
|
|
|
|
// let mut queue = AsyncQueue::<NoTls>::new_with_transaction(transaction);
|
|
|
|
|
|
|
|
// let result = queue.insert_task(&AsyncTask { number: 1 }).await.unwrap();
|
|
|
|
// assert_eq!(1, result);
|
|
|
|
|
|
|
|
// let result = queue.insert_task(&AsyncTask { number: 2 }).await.unwrap();
|
|
|
|
// assert_eq!(1, result);
|
|
|
|
|
|
|
|
// let result = queue.remove_tasks_type("common").await.unwrap();
|
|
|
|
// assert_eq!(2, result);
|
|
|
|
|
|
|
|
// queue.rollback().await.unwrap();
|
|
|
|
// }
|
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
|
|
|
}
|
|
|
|
}
|