Struct SqliteStorage

pub struct SqliteStorage<T, C = JsonCodec<String>> { /* private fields */ }

Available on crate feature sqlite only.

Represents a Storage that persists to Sqlite

Implementations

impl SqliteStorage<()>

pub async fn setup(pool: &Pool<Sqlite>) -> Result<(), Error>

Perform migrations for storage

pub fn migrations() -> Migrator

Get sqlite migrations without running them

impl<T> SqliteStorage<T>

pub fn new(pool: SqlitePool) -> Self

Create a new instance

pub fn new_with_config(pool: SqlitePool, config: Config) -> Self

Create a new instance with a custom config

impl<T, C> SqliteStorage<T, C>

pub async fn keep_alive_at( &mut self, worker: &Worker<Context>, last_seen: i64, ) -> Result<(), Error>

Keeps a storage notified that the worker is still alive manually

pub fn pool(&self) -> &Pool<Sqlite>

Expose the pool for other functionality, eg custom migrations

pub fn get_config(&self) -> &Config

Get the config used by the storage

impl<T, C> SqliteStorage<T, C>

pub fn codec(&self) -> &PhantomData<C>

Expose the code used

impl<T, C> SqliteStorage<T, C>

pub async fn retry( &mut self, worker_id: &WorkerId, job_id: &TaskId, ) -> Result<(), Error>

Puts the job instantly back into the queue Another Worker may consume

pub async fn kill( &mut self, worker_id: &WorkerId, job_id: &TaskId, ) -> Result<(), Error>

Kill a job

pub async fn reenqueue_orphaned( &self, count: i32, dead_since: DateTime<Utc>, ) -> Result<(), Error>

Add jobs that workers have disappeared to the queue

Trait Implementations

impl<T: Sync + Send, C: Send, Res: Serialize + Sync> Ack<T, Res, C> for SqliteStorage<T, C>

type Context = SqlContext

The data to fetch from context to allow acknowledgement

type AckError = Error

The error returned by the ack

async fn ack( &mut self, ctx: &Self::Context, res: &Response<Res>, ) -> Result<(), Error>

Acknowledges successful processing of the given request

impl<T, C> Backend<Request<T, SqlContext>> for SqliteStorage<T, C>

where C: Codec<Compact = String> + Send + 'static + Sync, C::Error: Error + 'static + Send + Sync, T: Serialize + DeserializeOwned + Sync + Send + Unpin + 'static,

type Stream = BackendStream<Pin<Box<dyn Stream<Item = Result<Option<Request<T, SqlContext>>, Error>> + Send>>>

The stream to be produced by the backend

type Layer = AckLayer<SqliteStorage<T, C>, T, SqlContext, C>

Returns the final decoration of layers

type Codec = JsonCodec<String>

Specifies the codec type used by the backend

fn poll(self, worker: &Worker<Context>) -> Poller<Self::Stream, Self::Layer>

Returns a poller that is ready for streaming

impl<J: 'static + Serialize + DeserializeOwned + Unpin + Send + Sync> BackendExpose<J> for SqliteStorage<J, JsonCodec<String>>

type Request = Request<J, Parts<SqlContext>>

The request type being handled by the backend

type Error = SqlError

The error returned during reading jobs and stats

async fn stats(&self) -> Result<Stat, Self::Error>

Returns the counts of jobs in different states

async fn list_jobs( &self, status: &State, page: i32, ) -> Result<Vec<Self::Request>, Self::Error>

Fetch jobs persisted in a backend

async fn list_workers(&self) -> Result<Vec<Worker<WorkerState>>, Self::Error>

List all Workers that are working on a backend

impl<T, C> Clone for SqliteStorage<T, C>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T, C> Debug for SqliteStorage<T, C>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, C> Storage for SqliteStorage<T, C>

where T: Serialize + DeserializeOwned + Send + 'static + Unpin + Sync, C: Codec<Compact = String> + Send + 'static + Sync, C::Error: Error + Send + Sync + 'static,

type Job = T

The type of job that can be persisted

type Error = Error

The error produced by the storage

type Context = SqlContext

This is the type that storages store as the metadata related to a job

type Compact = String

The format that the storage persists the jobs usually Vec<u8>

async fn push_request( &mut self, job: Request<Self::Job, SqlContext>, ) -> Result<Parts<SqlContext>, Self::Error>

Pushes a constructed request to a storage

async fn push_raw_request( &mut self, job: Request<Self::Compact, SqlContext>, ) -> Result<Parts<SqlContext>, Self::Error>

Pushes a constructed request to a storage

async fn schedule_request( &mut self, req: Request<Self::Job, SqlContext>, on: i64, ) -> Result<Parts<SqlContext>, Self::Error>

Push a request into the scheduled set

async fn fetch_by_id( &mut self, job_id: &TaskId, ) -> Result<Option<Request<Self::Job, SqlContext>>, Self::Error>

Fetch a job given an id

async fn len(&mut self) -> Result<i64, Self::Error>

Return the number of pending jobs from the queue

async fn reschedule( &mut self, job: Request<T, SqlContext>, wait: Duration, ) -> Result<(), Self::Error>

Reschedule a job

async fn update( &mut self, job: Request<Self::Job, SqlContext>, ) -> Result<(), Self::Error>

Update a job details

async fn is_empty(&mut self) -> Result<bool, Self::Error>

Returns true if there is no jobs in the storage

async fn vacuum(&mut self) -> Result<usize, Error>

Vacuum the storage, removes done and killed jobs

fn push( &mut self, job: Self::Job, ) -> impl Future<Output = Result<Parts<Self::Context>, Self::Error>> + Send

Pushes a job to a storage

fn schedule( &mut self, job: Self::Job, on: i64, ) -> impl Future<Output = Result<Parts<Self::Context>, Self::Error>> + Send

Push a job with defaults into the scheduled set