2020-03-22 21:18:36 +00:00
|
|
|
use crate::{db::Db, error::MyError};
|
2020-04-21 17:07:39 +00:00
|
|
|
use background_jobs::{dev::JobInfo, Stats};
|
2020-03-22 21:18:36 +00:00
|
|
|
use log::debug;
|
2020-04-21 17:07:39 +00:00
|
|
|
use tokio_postgres::types::Json;
|
2020-03-22 21:18:36 +00:00
|
|
|
use uuid::Uuid;
|
|
|
|
|
|
|
|
#[derive(Clone)]
|
|
|
|
pub struct Storage {
|
|
|
|
db: Db,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Storage {
|
|
|
|
pub fn new(db: Db) -> Self {
|
|
|
|
Storage { db }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[async_trait::async_trait]
|
2020-04-21 17:07:39 +00:00
|
|
|
impl background_jobs::dev::Storage for Storage {
|
2020-03-22 21:18:36 +00:00
|
|
|
type Error = MyError;
|
|
|
|
|
|
|
|
async fn generate_id(&self) -> Result<Uuid, MyError> {
|
|
|
|
// TODO: Ensure unique job id
|
|
|
|
Ok(Uuid::new_v4())
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn save_job(&self, job: JobInfo) -> Result<(), MyError> {
|
2020-04-02 18:51:10 +00:00
|
|
|
debug!(
|
|
|
|
"Inserting job {} status {} for queue {}",
|
|
|
|
job.id(),
|
|
|
|
job.status(),
|
|
|
|
job.queue()
|
|
|
|
);
|
|
|
|
self.db.pool().get().await?.execute(
|
2020-03-22 21:18:36 +00:00
|
|
|
"INSERT INTO jobs
|
|
|
|
(job_id, job_queue, job_timeout, job_updated, job_status, job_next_run, job_value, created_at)
|
|
|
|
VALUES
|
|
|
|
($1::UUID, $2::TEXT, $3::BIGINT, $4::TIMESTAMP, $5::TEXT, $6::TIMESTAMP, $7::JSONB, 'now')
|
|
|
|
ON CONFLICT (job_id)
|
|
|
|
DO UPDATE SET
|
|
|
|
job_updated = $4::TIMESTAMP,
|
|
|
|
job_status = $5::TEXT,
|
|
|
|
job_next_run = $6::TIMESTAMP,
|
|
|
|
job_value = $7::JSONB;",
|
2020-04-02 18:51:10 +00:00
|
|
|
&[&job.id(), &job.queue(), &job.timeout(), &job.updated_at().naive_utc(), &job.status().to_string(), &job.next_queue().map(|q| q.naive_utc()), &Json(&job)],
|
2020-03-22 21:18:36 +00:00
|
|
|
)
|
|
|
|
.await?;
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn fetch_job(&self, id: Uuid) -> Result<Option<JobInfo>, MyError> {
|
|
|
|
debug!(
|
|
|
|
"SELECT job_value FROM jobs WHERE job_id = $1::UUID LIMIT 1; [{}]",
|
|
|
|
id
|
|
|
|
);
|
2020-04-02 18:51:10 +00:00
|
|
|
let row_opt = self
|
|
|
|
.db
|
|
|
|
.pool()
|
|
|
|
.get()
|
|
|
|
.await?
|
|
|
|
.query_opt(
|
2020-03-22 21:18:36 +00:00
|
|
|
"SELECT job_value
|
|
|
|
FROM jobs
|
|
|
|
WHERE job_id = $1::UUID
|
|
|
|
LIMIT 1;",
|
|
|
|
&[&id],
|
|
|
|
)
|
|
|
|
.await?;
|
|
|
|
|
2020-04-02 18:51:10 +00:00
|
|
|
let row = if let Some(row) = row_opt {
|
2020-03-22 21:18:36 +00:00
|
|
|
row
|
|
|
|
} else {
|
|
|
|
return Ok(None);
|
|
|
|
};
|
|
|
|
|
2020-04-02 18:51:10 +00:00
|
|
|
let value: Json<JobInfo> = row.try_get(0)?;
|
2020-03-22 21:18:36 +00:00
|
|
|
|
2020-04-02 18:51:10 +00:00
|
|
|
Ok(Some(value.0))
|
2020-03-22 21:18:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
async fn fetch_job_from_queue(&self, queue: &str) -> Result<Option<JobInfo>, MyError> {
|
2020-04-02 18:51:10 +00:00
|
|
|
let row_opt = self
|
|
|
|
.db
|
|
|
|
.pool()
|
|
|
|
.get()
|
|
|
|
.await?
|
2020-03-22 21:18:36 +00:00
|
|
|
.query_opt(
|
|
|
|
"UPDATE jobs
|
|
|
|
SET
|
|
|
|
job_status = 'Running',
|
|
|
|
job_updated = 'now'
|
|
|
|
WHERE
|
|
|
|
job_id = (
|
|
|
|
SELECT job_id
|
|
|
|
FROM jobs
|
|
|
|
WHERE
|
|
|
|
job_queue = $1::TEXT
|
|
|
|
AND
|
|
|
|
(
|
|
|
|
job_next_run IS NULL
|
|
|
|
OR
|
|
|
|
job_next_run < now()
|
|
|
|
)
|
|
|
|
AND
|
|
|
|
(
|
|
|
|
job_status = 'Pending'
|
|
|
|
OR
|
|
|
|
(
|
|
|
|
job_status = 'Running'
|
|
|
|
AND
|
|
|
|
NOW() > (INTERVAL '1 millisecond' * job_timeout + job_updated)
|
|
|
|
)
|
|
|
|
)
|
|
|
|
LIMIT 1
|
|
|
|
FOR UPDATE SKIP LOCKED
|
|
|
|
)
|
|
|
|
RETURNING job_value;",
|
|
|
|
&[&queue],
|
|
|
|
)
|
|
|
|
.await?;
|
|
|
|
|
2020-04-02 18:51:10 +00:00
|
|
|
let row = if let Some(row) = row_opt {
|
2020-03-22 21:18:36 +00:00
|
|
|
row
|
|
|
|
} else {
|
|
|
|
return Ok(None);
|
|
|
|
};
|
|
|
|
|
2020-04-02 18:51:10 +00:00
|
|
|
let value: Json<JobInfo> = row.try_get(0)?;
|
|
|
|
let job = value.0;
|
2020-03-22 21:18:36 +00:00
|
|
|
|
|
|
|
debug!("Found job {} in queue {}", job.id(), queue);
|
|
|
|
|
|
|
|
Ok(Some(job))
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn queue_job(&self, _queue: &str, _id: Uuid) -> Result<(), MyError> {
|
|
|
|
// Queue Job is a no-op, since jobs are always in their queue
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn run_job(&self, _id: Uuid, _runner_id: Uuid) -> Result<(), MyError> {
|
|
|
|
// Run Job is a no-op, since jobs are marked running at fetch
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn delete_job(&self, id: Uuid) -> Result<(), MyError> {
|
|
|
|
debug!("Deleting job {}", id);
|
2020-04-02 18:51:10 +00:00
|
|
|
self.db
|
|
|
|
.pool()
|
|
|
|
.get()
|
|
|
|
.await?
|
|
|
|
.execute("DELETE FROM jobs WHERE job_id = $1::UUID;", &[&id])
|
2020-03-22 21:18:36 +00:00
|
|
|
.await?;
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn get_stats(&self) -> Result<Stats, MyError> {
|
|
|
|
// TODO: Stats are unimplemented
|
|
|
|
Ok(Stats::default())
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn update_stats<F>(&self, _f: F) -> Result<(), MyError>
|
|
|
|
where
|
|
|
|
F: Fn(Stats) -> Stats + Send,
|
|
|
|
{
|
|
|
|
// TODO: Stats are unimplemented
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|