Struct JobCall 

pub struct JobCall<T = Bytes> { /* private fields */ }

Representation of a job call event

These events come from Producers, which may be listening for on-chain events (e.g. TangleProducer), or simply waiting for a timer to end (e.g. CronJob).

A JobCall consists of two parts: a header and a body.

Header

The header is a Parts containing the JobId and any metadata associated with the call. This metadata is used by argument extractors, see the extract module for more information.

Body

The body will typically contain the arguments associated with the job call, in a producer-specific format. For example, the TangleProducer will produce JobCalls with a body compatible with the TangleArg extractors.

Implementations

impl<T> JobCall<T>

pub fn empty() -> JobCall<T>

where T: Default,

Create an empty JobCall

This is useful for producers such as CronJob, where the intention is to simply trigger a job with no extra arguments.

pub fn new<J>(job_id: J, body: T) -> JobCall<T>

where J: Into<JobId>,

Create a new JobCall with the given job_id and body

Examples

use blueprint_sdk::JobCall;

const MY_JOB_ID: u8 = 0;

let call = JobCall::new(MY_JOB_ID, ());
assert_eq!(call.job_id(), MY_JOB_ID.into());

pub fn from_parts(parts: Parts, body: T) -> JobCall<T>

Create a new JobCall with a pre-defined parts and body

Examples

use blueprint_sdk::JobCall;
use blueprint_sdk::job::call::Parts;

const MY_JOB_ID: u8 = 0;
let parts = Parts::new(MY_JOB_ID);

let call = JobCall::from_parts(parts, ());
assert_eq!(call.job_id(), MY_JOB_ID.into());

pub fn job_id(&self) -> JobId

Get the job id of this JobCall

pub fn job_id_mut(&mut self) -> &mut JobId

Get a mutable reference to the job id of this JobCall

pub fn metadata(&self) -> &MetadataMap<MetadataValue>

Get a reference to the call metadata

pub fn metadata_mut(&mut self) -> &mut MetadataMap<MetadataValue>

Get a mutable reference to the call metadata

pub fn extensions(&self) -> &Extensions

Get a reference to the call extensions

pub fn extensions_mut(&mut self) -> &mut Extensions

Get a mutable reference to the call extensions

pub fn body(&self) -> &T

Get a reference to the body

pub fn into_body(self) -> T

Consume the JobCall and return the body

pub fn into_parts(self) -> (Parts, T)

pub fn map<F, U>(self, f: F) -> JobCall<U>

where F: FnOnce(T) -> U,

Takes a closure and applies it to the body

Examples

use blueprint_sdk::job::call::JobCall;

let call = JobCall::new(0, ());
let new_call = call.map(|_| "Hello!");
assert_eq!(*new_call.body(), "Hello!");

Trait Implementations

impl<T> Clone for JobCall<T>

where T: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for JobCall<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for JobCall<T>

where T: Default,

fn default() -> JobCall<T>

Returns the “default value” for a type.

impl<Ctx> FromJobCall<Ctx> for JobCall

where Ctx: Send + Sync,

type Rejection = Infallible

If the extractor fails it’ll use this “rejection” type. A rejection is a kind of error that can be converted into a job result.

async fn from_job_call( call: JobCall, _: &Ctx, ) -> Result<JobCall, <JobCall as FromJobCall<Ctx>>::Rejection>

Perform the extraction.

impl JobCallExt for JobCall

fn extract<E, M>( self, ) -> impl Future<Output = Result<E, <E as FromJobCall<(), M>>::Rejection>> + Send

where E: FromJobCall<(), M> + 'static, M: 'static,

Apply an extractor to this JobCall.

fn extract_with_context<E, Ctx, M>( self, ctx: &Ctx, ) -> impl Future<Output = Result<E, <E as FromJobCall<Ctx, M>>::Rejection>> + Send

where E: FromJobCall<Ctx, M> + 'static, Ctx: Send + Sync,

Apply an extractor that requires some context to this JobCall.

fn extract_parts<E>( &mut self, ) -> impl Future<Output = Result<E, <E as FromJobCallParts<()>>::Rejection>> + Send

where E: FromJobCallParts<()> + 'static,

Apply a Parts extractor to this JobCall.

async fn extract_parts_with_context<'a, E, Ctx>( &'a mut self, ctx: &'a Ctx, ) -> Result<E, <E as FromJobCallParts<Ctx>>::Rejection>

where E: FromJobCallParts<Ctx> + 'static, Ctx: Send + Sync,

Apply a Parts extractor that requires some state to this Request.

impl Predicate<JobCall> for MatchesContract

type Request = JobCall

The type of requests returned by check.

fn check( &mut self, call: <MatchesContract as Predicate<JobCall>>::Request, ) -> Result<<MatchesContract as Predicate<JobCall>>::Request, Box<dyn Error + Send + Sync>>

Check whether the given request should be forwarded.

impl Predicate<JobCall> for MatchesEvent

type Request = JobCall

The type of requests returned by check.

fn check( &mut self, call: <MatchesEvent as Predicate<JobCall>>::Request, ) -> Result<<MatchesEvent as Predicate<JobCall>>::Request, Box<dyn Error + Send + Sync>>

Check whether the given request should be forwarded.

impl Predicate<JobCall> for MatchesServiceId

type Request = JobCall

The type of requests returned by check.

fn check( &mut self, call: <MatchesServiceId as Predicate<JobCall>>::Request, ) -> Result<<MatchesServiceId as Predicate<JobCall>>::Request, Box<dyn Error + Send + Sync>>

Check whether the given request should be forwarded.

impl<J, T, Ctx, B> Service<JobCall<B>> for JobService<J, T, Ctx>

where J: Job<T, Ctx> + Clone + Send + 'static, B: Into<Bytes> + Send + 'static, Ctx: Clone + Send + Sync,

type Response = Option<JobResult>

Responses given by the service.

type Error = Box<dyn Error + Send + Sync>

Errors produced by the service.

type Future = IntoServiceFuture<<J as Job<T, Ctx>>::Future>

The future response value.

fn poll_ready( &mut self, _cx: &mut Context<'_>, ) -> Poll<Result<(), <JobService<J, T, Ctx> as Service<JobCall<B>>>::Error>>

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

fn call( &mut self, call: JobCall<B>, ) -> <JobService<J, T, Ctx> as Service<JobCall<B>>>::Future

Process the request and return the response asynchronously.

impl<B> Service<JobCall<B>> for Router

where B: Into<Bytes>,

type Response = Option<Vec<JobResult>>

Responses given by the service.

type Error = Box<dyn Error + Send + Sync>

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<<Router as Service<JobCall<B>>>::Response, <Router as Service<JobCall<B>>>::Error>> + Send>>

The future response value.

fn poll_ready( &mut self, _: &mut Context<'_>, ) -> Poll<Result<(), <Router as Service<JobCall<B>>>::Error>>

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

fn call(&mut self, call: JobCall<B>) -> <Router as Service<JobCall<B>>>::Future

Process the request and return the response asynchronously.

impl<S> Service<JobCall> for AddBlockEvents<S>

where S: Service<JobCall> + Send + Clone + 'static, <S as Service<JobCall>>::Future: Send + 'static, <S as Service<JobCall>>::Error: Into<Box<dyn Error + Send + Sync>> + Send + 'static, <S as Service<JobCall>>::Response: 'static,

type Response = <S as Service<JobCall>>::Response

Responses given by the service.

type Error = Box<dyn Error + Send + Sync>

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<<AddBlockEvents<S> as Service<JobCall>>::Response, <AddBlockEvents<S> as Service<JobCall>>::Error>> + Send>>

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<(), <AddBlockEvents<S> as Service<JobCall>>::Error>>

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

fn call( &mut self, job_call: JobCall, ) -> <AddBlockEvents<S> as Service<JobCall>>::Future

Process the request and return the response asynchronously.

impl<S> Service<JobCall> for TangleSubmissionService<S>

where S: Service<JobCall, Response = Option<JobResult>>,

type Response = <S as Service<JobCall>>::Response

Responses given by the service.

type Error = <S as Service<JobCall>>::Error

Errors produced by the service.

type Future = TangleSubmissionFuture<<S as Service<JobCall>>::Future>

The future response value.

fn poll_ready( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<(), <TangleSubmissionService<S> as Service<JobCall>>::Error>>

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

fn call( &mut self, call: JobCall, ) -> <TangleSubmissionService<S> as Service<JobCall>>::Future

Process the request and return the response asynchronously.