Struct apalis_sql::sqlite::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: Serialize + DeserializeOwned> 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

pub async fn keep_alive_at<Service>( &mut self, worker_id: &WorkerId, 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> SqliteStorage<T>

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_failed(&mut self) -> Result<(), Error>

Add jobs that failed back to the queue if there are still remaining attemps

pub async fn reenqueue_orphaned(&self, timeout: i64) -> Result<(), Error>

Add jobs that workers have disappeared to the queue

Trait Implementations

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

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: &Result<Res, Error>, ) -> Result<(), Error>

Acknowledges successful processing of the given request

impl<T: Serialize + DeserializeOwned + Sync + Send + Unpin + 'static, Res> Backend<Request<T>, Res> for SqliteStorage<T>

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

The stream to be produced by the backend

type Layer = AckLayer<SqliteStorage<T>, T, Res>

Returns the final decoration of layers

fn poll<Svc>(self, worker: WorkerId) -> Poller<Self::Stream, Self::Layer>

Returns a poller that is ready for streaming

impl<T> Clone for SqliteStorage<T>

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,

type Job = T

The type of job that can be persisted

type Error = Error

The error produced by the storage

type Identifier = TaskId

Jobs must have Ids.

async fn push(&mut self, job: Self::Job) -> Result<TaskId, Self::Error>

Pushes a job to a storage

async fn schedule( &mut self, job: Self::Job, on: i64, ) -> Result<TaskId, Self::Error>

Push a job into the scheduled set

async fn fetch_by_id( &mut self, job_id: &TaskId, ) -> Result<Option<Request<Self::Job>>, 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>, wait: Duration, ) -> Result<(), Self::Error>

Reschedule a job

async fn update(&mut self, job: Request<Self::Job>) -> 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