Struct MysqlStorage

pub struct MysqlStorage<T, C = JsonCodec<Value>>
where
    C: Codec,
{ /* private fields */ }

Available on crate feature mysql only.

Represents a Storage that persists to MySQL

Implementations

impl MysqlStorage<(), JsonCodec<Value>>

pub fn migrations() -> Migrator

Get mysql migrations without running them

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

Do migrations for mysql

impl<T> MysqlStorage<T>

where T: Serialize + DeserializeOwned,

pub fn new(pool: MySqlPool) -> Self

Create a new instance from a pool

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

Create a new instance from a pool and custom config

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

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: Codec> MysqlStorage<T, C>

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

Kill a job

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

Puts the job instantly back into the queue

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

Readd jobs that are abandoned to the queue

Trait Implementations

impl<T, Res, C> Ack<T, Res, C> for MysqlStorage<T, C>

where T: Sync + Send, Res: Serialize + Send + 'static + Sync, C: Codec<Compact = Value> + Send, C::Error: Debug,

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<Req, C> Backend<Request<Req, SqlContext>> for MysqlStorage<Req, C>

where Req: Serialize + DeserializeOwned + Sync + Send + 'static, C: Codec<Compact = Value> + Send + 'static + Sync, C::Error: Error + 'static + Send + Sync,

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

The stream to be produced by the backend

type Layer = AckLayer<MysqlStorage<Req, C>, Req, SqlContext, C>

Returns the final decoration of layers

type Codec = C

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 MysqlStorage<J>

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 MysqlStorage<T, C>

where C: Codec,

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 MysqlStorage<T, C>

where C: Codec, C::Compact: Debug,

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

Formats the value using the given formatter.

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

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

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 = Value

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>, Error>

Pushes a constructed request to a storage

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

Pushes a constructed request to a storage

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

Push a request into the scheduled set

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

Fetch a job given an id

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

Return the number of pending jobs from the queue

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

Reschedule a job

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