Struct apalis_redis::RedisStorage

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

Represents a Storage that uses Redis for storage.

Implementations

impl<T: Job> RedisStorage<T>

pub fn new(conn: ConnectionManager) -> Self

Start a new connection

pub async fn connect<S: IntoConnectionInfo>( redis: S ) -> Result<Self, RedisError>

Connect to a redis url

pub fn get_connection(&self) -> ConnectionManager

Get current connection

Trait Implementations

impl<T> Clone for RedisStorage<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 for RedisStorage<T>

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

Formats the value using the given formatter.

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

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<JobId>> + 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<JobId>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Push a job into the scheduled set

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

Get the stream of jobs

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

Kill a job

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 fetch_by_id<'life0, 'life1, 'async_trait>( &'life0 self, job_id: &'life1 JobId ) -> Pin<Box<dyn Future<Output = StorageResult<Option<JobRequest<Self::Output>>>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch a job given an id

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

Update a job details

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

Acknowledge a job which returns Ok

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

Retry a job

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

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

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

Used for scheduling jobs

fn reenqueue_active<'life0, 'life1, 'async_trait>( &'life0 mut self, job_ids: Vec<&'life1 JobId> ) -> Pin<Box<dyn Future<Output = StorageResult<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Used to recover jobs when a Worker shuts down.

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,

Reschedule a job