Struct apalis_redis::RedisStorage

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

Represents a Storage that uses Redis for storage.

Implementations

impl<T: Job + Serialize + DeserializeOwned> RedisStorage<T>

pub fn new(conn: ConnectionManager) -> Self

Start a new connection

pub fn new_with_config(conn: ConnectionManager, config: Config) -> Self

Start a new connection providing custom config

pub fn get_connection(&self) -> ConnectionManager

Get current connection

impl<T> RedisStorage<T>

pub async fn retry( &mut self, worker_id: &WorkerId, task_id: &TaskId ) -> Result<i32, RedisError>

where T: Send + DeserializeOwned + Serialize + Job + Unpin + Sync + 'static,

Attempt to retry a job

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

where T: Send + DeserializeOwned + Serialize + Job + Unpin + Sync + 'static,

Attempt to kill a job

pub async fn enqueue_scheduled( &mut self, count: usize ) -> Result<usize, RedisError>

Required to add scheduled jobs to the active set

pub async fn reenqueue_active( &mut self, job_ids: Vec<&TaskId> ) -> Result<(), RedisError>

Re-enqueue some jobs that might be abandoned.

pub async fn reenqueue_orphaned( &mut self, count: usize, dead_since: i64 ) -> Result<usize, RedisError>

Re-enqueue some jobs that might be orphaned.

Trait Implementations

impl<T: Sync> Ack<T> for RedisStorage<T>

type Acknowledger = TaskId

The data to fetch from context to allow acknowledgement

type Error = RedisError

The error returned by the ack

async fn ack( &self, worker_id: &WorkerId, task_id: &Self::Acknowledger ) -> Result<(), RedisError>

Acknowledges successful processing of the given request

impl<T: Job + Serialize + DeserializeOwned + Sync + Send + Unpin + 'static> Backend<Request<T>> for RedisStorage<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<RedisStorage<T>, T>

Returns the final decoration of layers

fn common_layer(&self, worker_id: WorkerId) -> Self::Layer

Allows the backend to decorate the service with Layer

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

Returns a poller that is ready for streaming

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 Job = T

The type of job that can be persisted

type Error = RedisError

The error produced by the storage

type Identifier = TaskId

Jobs must have Ids.

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

Pushes a job to a storage

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

Push a job into the scheduled set

async fn len(&self) -> Result<i64, RedisError>

Return the number of pending jobs from the queue

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

Fetch a job given an id

async fn update(&self, job: Request<T>) -> Result<(), RedisError>

Update a job details

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

Reschedule a job

async fn is_empty(&self) -> Result<bool, RedisError>

Returns true if there is no jobs in the storage

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

Vacuum the storage, removes done and killed jobs