Struct apalis_core::request::JobRequest

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

Represents a job which can be serialized and executed

Implementations

impl<T> JobRequest<T>

pub fn new(job: T) -> Self

Creates a new JobRequest

pub fn new_with_context(job: T, ctx: JobContext) -> Self

Creates a Job request with context provided

pub fn inner(&self) -> &T

Get the underlying reference of the [Job]

pub fn context_mut(&mut self) -> &mut JobContext

Gets a mutable reference to the job context.

pub fn context(&self) -> &JobContext

Gets a reference to the job context.

pub fn record_attempt(&mut self)

Records a job attempt

Methods from Deref<Target = JobContext>

pub fn data_opt<D: Any + Send + Sync>(&self) -> Option<&D>

Get a reference to a type previously inserted on this JobContext.

Example

let mut ctx = JobContext::new(1.to_string());
assert!(ctx.data_opt::<i32>().is_none());
ctx.insert(5i32);

assert_eq!(ctx.data_opt::<i32>(), Some(&5i32));

pub fn insert<D: Any + Send + Sync>(&mut self, data: D) -> Option<D>

Insert a type into this JobContext.

Important for embedding data for a job. If a extension of this type already existed, it will be returned.

Example

let mut ctx = JobContext::new(1.to_string());
assert!(ctx.insert(5i32).is_none());
assert!(ctx.insert(4u8).is_none());
assert_eq!(ctx.insert(9i32), Some(5i32));

pub fn set_max_attempts(&mut self, max_attempts: i32)

Set the number of attempts

pub fn max_attempts(&self) -> i32

Gets the maximum attempts for a job. Default 25

pub fn id(&self) -> String

Get the id for a job

pub fn attempts(&self) -> i32

Gets the current attempts for a job. Default 0

pub fn set_attempts(&mut self, attempts: i32)

Set the number of attempts

pub fn done_at(&self) -> &Option<DateTime<Utc>>

Get the time a job was done

pub fn set_done_at(&mut self, done_at: Option<DateTime<Utc>>)

Set the time a job was done

pub fn run_at(&self) -> &DateTime<Utc>

Get the time a job is supposed to start

pub fn set_run_at(&mut self, run_at: DateTime<Utc>)

Set the time a job should run

pub fn lock_at(&self) -> &Option<DateTime<Utc>>

Get the time a job was locked

pub fn set_lock_at(&mut self, lock_at: Option<DateTime<Utc>>)

Set the lock_at value

pub fn status(&self) -> &JobState

Get the job status

pub fn set_status(&mut self, status: JobState)

Set the job status

pub fn lock_by(&self) -> &Option<String>

Get the time a job was locked

pub fn set_lock_by(&mut self, lock_by: Option<String>)

Set lock_by

pub fn last_error(&self) -> &Option<String>

Get the time a job was locked

pub fn set_last_error(&mut self, error: String)

Set the last error

Trait Implementations

impl<T: Clone> Clone for JobRequest<T>

fn clone(&self) -> JobRequest<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for JobRequest<T>

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

Formats the value using the given formatter.

impl<T> Deref for JobRequest<T>

type Target = JobContext

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> DerefMut for JobRequest<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de, T> Deserialize<'de> for JobRequest<T> where
    T: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T> Policy<JobRequest<T>, JobResult, JobError> for DefaultRetryPolicy where
    T: Clone, 

Available on crate feature retry only.

type Future = Ready<DefaultRetryPolicy>

The Future type returned by Policy::retry.

fn retry(
    &self,
    req: &JobRequest<T>,
    result: Result<&JobResult, &JobError>
) -> Option<Self::Future>

Check the policy if a certain request should be retried.

fn clone_request(&self, req: &JobRequest<T>) -> Option<JobRequest<T>>

Tries to clone a request before being passed to the inner service.

impl<T> Serialize for JobRequest<T> where
    T: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<J, S, T> Service<JobRequest<J>> for AddExtension<S, T> where
    S: Service<JobRequest<J>>,
    T: Clone + Send + Sync + 'static, 

Available on crate feature extensions only.

type Response = <S as Service<JobRequest<J>>>::Response

Responses given by the service.

type Error = <S as Service<JobRequest<J>>>::Error

Errors produced by the service.

type Future = <S as Service<JobRequest<J>>>::Future

The future response value.

fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, req: JobRequest<J>) -> Self::Future

Process the request and return the response asynchronously.

impl<S, J, F> Service<JobRequest<J>> for PrometheusService<S> where
    S: Service<JobRequest<J>, Response = JobResult, Error = JobError, Future = F>,
    F: Future<Output = Result<JobResult, JobError>> + 'static,
    J: Job, 

Available on crate feature prometheus only.

type Response = <S as Service<JobRequest<J>>>::Response

Responses given by the service.

type Error = <S as Service<JobRequest<J>>>::Error

Errors produced by the service.

type Future = ResponseFuture<F>

The future response value.

fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, request: JobRequest<J>) -> Self::Future

Process the request and return the response asynchronously.

impl<S, J, F> Service<JobRequest<J>> for SentryJobService<S> where
    S: Service<JobRequest<J>, Response = JobResult, Error = JobError, Future = F>,
    F: Future<Output = Result<JobResult, JobError>> + 'static,
    J: Job, 

Available on crate feature sentry only.

type Response = <S as Service<JobRequest<J>>>::Response

Responses given by the service.

type Error = <S as Service<JobRequest<J>>>::Error

Errors produced by the service.

type Future = SentryHttpFuture<<S as Service<JobRequest<J>>>::Future>

The future response value.

fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, request: JobRequest<J>) -> Self::Future

Process the request and return the response asynchronously.

impl<J, S, OnRequestT, OnResponseT, OnFailureT, MakeSpanT, F> Service<JobRequest<J>> for Trace<S, MakeSpanT, OnRequestT, OnResponseT, OnFailureT> where
    S: Service<JobRequest<J>, Response = JobResult, Error = JobError, Future = F> + Unpin + Send + 'static,
    S::Error: Display + 'static,
    MakeSpanT: MakeSpan<J>,
    OnRequestT: OnRequest<J>,
    OnResponseT: OnResponse + Clone + 'static,
    F: Future<Output = Result<JobResult, JobError>> + 'static,
    OnFailureT: OnFailure + Clone + 'static, 

Available on crate feature trace only.

type Response = JobResult

Responses given by the service.

type Error = JobError

Errors produced by the service.

type Future = ResponseFuture<F, OnResponseT, OnFailureT>

The future response value.

fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, req: JobRequest<J>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Request> Service<JobRequest<Request>> for JobFn<T> where
    Request: Debug + 'static,
    T: Fn(Request, JobContext) -> F,
    F: Future<Output = Result<JobResult, JobError>> + 'static,
    Request: Job, 

type Response = JobResult

Responses given by the service.

type Error = JobError

Errors produced by the service.

type Future = JobFnHttpFuture<F>

The future response value.

fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, job: JobRequest<Request>) -> Self::Future

Process the request and return the response asynchronously.