Struct apalis_sql::sqlite::SqliteStorage

pub struct SqliteStorage<T> { /* private fields */ }

Available on crate feature sqlite only.

Represents a Storage that persists to Sqlite

Implementations

impl<T: Job> SqliteStorage<T>

pub fn new(pool: SqlitePool) -> Self

Construct a new Storage from a pool

pub async fn connect<S: Into<String>>(db: S) -> Result<Self, Error>

Connect to a database given a url

pub async fn setup(&self) -> Result<(), Error>

Perform migrations for storage

pub async fn keep_alive_at<Service>(
    &mut self,
    worker_id: String,
    last_seen: DateTime<Utc>
) -> StorageResult<()>

Keeps a storage notified that the worker is still alive manually

Trait Implementations

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: Debug> Debug for SqliteStorage<T>

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

Formats the value using the given formatter.

impl<J: 'static + Job + Serialize + DeserializeOwned> JobStreamExt<J> for SqliteStorage<J>

fn counts<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Counts, JobError>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Returns the counts of jobs in different states

fn list_jobs<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    status: &'life1 JobState,
    page: i32
) -> Pin<Box<dyn Future<Output = Result<Vec<JobRequest<J>>, JobError>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Fetch jobs persisted from storage

fn list_workers<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Vec<JobStreamWorker>, JobError>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

List all Workers that are working on a Job Stream

impl<T> Storage for SqliteStorage<T>where
    T: Job + Serialize + DeserializeOwned + Send + 'static + Unpin,

fn heartbeat<'life0, 'async_trait>(
    &'life0 mut self,
    pulse: StorageWorkerPulse
) -> Pin<Box<dyn Future<Output = StorageResult<bool>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Used for scheduling jobs via StorageWorkerPulse signals

fn retry<'life0, 'async_trait>(
    &'life0 mut self,
    worker_id: String,
    job_id: String
) -> Pin<Box<dyn Future<Output = StorageResult<()>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

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

type Output = T

The type of job that can be persisted

fn push<'life0, 'async_trait>(
    &'life0 mut self,
    job: Self::Output
) -> Pin<Box<dyn Future<Output = StorageResult<()>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Pushes a job to a storage

fn schedule<'life0, 'async_trait>(
    &'life0 mut self,
    job: Self::Output,
    on: DateTime<Utc>
) -> Pin<Box<dyn Future<Output = StorageResult<()>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Push a job into the scheduled set

fn fetch_by_id<'life0, 'async_trait>(
    &'life0 self,
    job_id: String
) -> Pin<Box<dyn Future<Output = StorageResult<Option<JobRequest<Self::Output>>>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Fetch a job given an id

fn kill<'life0, 'async_trait>(
    &'life0 mut self,
    worker_id: String,
    job_id: String
) -> Pin<Box<dyn Future<Output = StorageResult<()>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Kill a job that returns [JobResult::Kill]

fn consume(&mut self, worker_id: String, interval: Duration) -> JobStreamResult<T>

Get the stream of jobs

fn len<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = StorageResult<i64>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Return the number of pending jobs from the queue

fn ack<'life0, 'async_trait>(
    &'life0 mut self,
    worker_id: String,
    job_id: String
) -> Pin<Box<dyn Future<Output = StorageResult<()>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Acknowledge a job which returns [JobResult::Success]

fn reschedule<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    job: &'life1 JobRequest<T>,
    wait: Duration
) -> Pin<Box<dyn Future<Output = StorageResult<()>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Kill a job that returns [JobResult::Reschedule] [JobResult::Reschedule]: crate::response::JobResult

fn update_by_id<'life0, 'life1, 'async_trait>(
    &'life0 self,
    job_id: String,
    job: &'life1 JobRequest<Self::Output>
) -> Pin<Box<dyn Future<Output = StorageResult<()>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Update a job details

fn keep_alive<'life0, 'async_trait, Service>(
    &'life0 mut self,
    worker_id: String
) -> Pin<Box<dyn Future<Output = StorageResult<()>> + Send + 'async_trait>>where
    Service: 'async_trait,
    Self: 'async_trait,
    'life0: 'async_trait,

Called by a Worker to keep the storage alive and prevent jobs from being deemed as orphaned

fn reenqueue_active<'life0, 'async_trait>(
    &'life0 mut self,
    _job_ids: Vec<String, Global>
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait, Global>>where
    'life0: 'async_trait,
    Self: 'async_trait + Send,

Used to recover jobs when a Worker shuts down.