Struct Job 

pub struct Job<M>
where
    M: Executable + Clone,
{
    pub context: JobContext,
    pub data: M,
}

Fields

context: JobContext

data: M

Implementations

impl<M> Job<M>

where M: Executable + Clone,

pub fn new(job: M) -> Job<M>

Create a new job.

#[derive(BackgroundJob, Serialize, Deserialize, Debug, Clone)]
pub struct Print {
   pub number: i32,
}

#[aj::async_trait]
impl Execute for Print {
    type Output = ();

    async fn execute(&mut self, _: &JobContext) -> Self::Output {
        println!("Hello, {}", self.number);
    }
}

let job = Job::new(Print {
    number: 1,
})

pub fn id(&self) -> &str

Get Job Id

pub fn set_id(self, id: String) -> Job<M>

Custom job id

pub fn set_context(self, context: JobContext) -> Job<M>

pub fn context(self, context: JobContext) -> Job<M>

pub fn set_job_type(self, job_type: JobType) -> Job<M>

Set Job Type

pub fn job_type(self, job_type: JobType) -> Job<M>

pub fn schedule_at(self, schedule_at: DateTime<Utc>) -> Job<M>

Schedule job to run at specific time

job.schedule_at(get_now() + Duration::seconds(2));

pub fn delay(self, after: TimeDelta) -> Job<M>

Schedule job to run after specific time

job.delay(Duration::seconds(2));

pub fn cron(self, cron_expression: &str) -> Job<M>

Schedule job run by Cron Pattern

job.cron("* * * * * * *");

pub fn set_retry(self, retry: Retry) -> Job<M>

Set Retry logic for job job.set_retry(aj::Retry::default())

pub fn retry(self, retry: Retry) -> Job<M>

impl<M> Job<M>

where M: Executable + Clone + Serialize + Sync + Send + 'static,

pub fn is_ready(&self) -> bool

pub fn is_queued(&self) -> bool

pub fn is_running(&self) -> bool

pub fn is_cancelled(&self) -> bool

impl<M> Job<M>

where M: BackgroundJob + Executable + Unpin + Send + Sync + Clone + Serialize + DeserializeOwned + 'static,

pub async fn run(self) -> Result<String, Error>

It will wait to WorkQueue received and insert job into backend

pub fn just_run(self)

It will just send message to WorkQueue and no gurantee job is inserted to backend

Trait Implementations

impl<M> Clone for Job<M>

where M: Clone + Executable,

fn clone(&self) -> Job<M>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M> Debug for Job<M>

where M: Debug + Executable + Clone,

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

Formats the value using the given formatter.

impl<'de, M> Deserialize<'de> for Job<M>

where M: Executable + Clone + Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<Job<M>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<M> Serialize for Job<M>

where M: Executable + Clone + Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.