Struct apalis_core::request::Request

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

Represents a job which can be serialized and executed

Implementations

impl<T> Request<T>

pub fn new(req: T) -> Self

Creates a new Request

pub fn new_with_data(req: T, data: Extensions) -> Self

Creates a request with context provided

pub fn inner(&self) -> &T

Get the underlying reference of the request

pub fn take(self) -> T

Take the underlying reference of the request

Methods from Deref<Target = Extensions>

pub fn insert<T: Clone + Send + Sync + 'static>(&mut self, val: T) -> Option<T>

Insert a type into this Extensions.

If a extension of this type already existed, it will be returned.

Example

let mut ext = Extensions::new();
assert!(ext.insert(5i32).is_none());
assert!(ext.insert(4u8).is_none());
assert_eq!(ext.insert(9i32), Some(5i32));

pub fn get<T: Send + Sync + 'static>(&self) -> Option<&T>

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

Example

let mut ext = Extensions::new();
assert!(ext.get::<i32>().is_none());
ext.insert(5i32);

assert_eq!(ext.get::<i32>(), Some(&5i32));

pub fn get_mut<T: Send + Sync + 'static>(&mut self) -> Option<&mut T>

Get a mutable reference to a type previously inserted on this Extensions.

Example

let mut ext = Extensions::new();
ext.insert(String::from("Hello"));
ext.get_mut::<String>().unwrap().push_str(" World");

assert_eq!(ext.get::<String>().unwrap(), "Hello World");

pub fn remove<T: Send + Sync + 'static>(&mut self) -> Option<T>

Remove a type from this Extensions.

If a extension of this type existed, it will be returned.

Example

let mut ext = Extensions::new();
ext.insert(5i32);
assert_eq!(ext.remove::<i32>(), Some(5i32));
assert!(ext.get::<i32>().is_none());

pub fn clear(&mut self)

Clear the Extensions of all inserted extensions.

Example

let mut ext = Extensions::new();
ext.insert(5i32);
ext.clear();

assert!(ext.get::<i32>().is_none());

pub fn is_empty(&self) -> bool

Check whether the extension set is empty or not.

Example

let mut ext = Extensions::new();
assert!(ext.is_empty());
ext.insert(5i32);
assert!(!ext.is_empty());

pub fn len(&self) -> usize

Get the number of extensions available.

Example

let mut ext = Extensions::new();
assert_eq!(ext.len(), 0);
ext.insert(5i32);
assert_eq!(ext.len(), 1);

pub fn extend(&mut self, other: Self)

Extends self with another Extensions.

If an instance of a specific type exists in both, the one in self is overwritten with the one from other.

Example

let mut ext_a = Extensions::new();
ext_a.insert(8u8);
ext_a.insert(16u16);

let mut ext_b = Extensions::new();
ext_b.insert(4u8);
ext_b.insert("hello");

ext_a.extend(ext_b);
assert_eq!(ext_a.len(), 3);
assert_eq!(ext_a.get::<u8>(), Some(&4u8));
assert_eq!(ext_a.get::<u16>(), Some(&16u16));
assert_eq!(ext_a.get::<&'static str>().copied(), Some("hello"));

Trait Implementations

impl<T: Send + 'static + Sync> Backend<Request<T>> for MemoryStorage<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 = ServiceBuilder<Identity>

Returns the final decoration of layers

fn common_layer(&self, _worker: 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> Backend<Request<T>> for RequestStream<Request<T>>

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

The stream to be produced by the backend

type Layer = ServiceBuilder<Identity>

Returns the final decoration of layers

fn common_layer(&self, _worker: 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> Clone for Request<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Request<T>

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

Formats the value using the given formatter.

impl<T> Deref for Request<T>

type Target = Extensions

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> DerefMut for Request<T>

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

Mutably dereferences the value.

impl<'de, T> Deserialize<'de> for Request<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> Serialize for Request<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<SV, A, J> Service<Request<J>> for AckService<SV, A, J>

where SV: Service<Request<J>> + Send + Sync + 'static, SV::Error: Error + Send + Sync + 'static, <SV as Service<Request<J>>>::Future: Send + 'static, A: Ack<J> + Send + 'static + Clone + Sync, J: 'static, <SV as Service<Request<J>>>::Response: Send, <A as Ack<J>>::Acknowledger: Sync + Send + Clone,

type Response = <SV as Service<Request<J>>>::Response

Responses given by the service.

type Error = <SV as Service<Request<J>>>::Error

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<<AckService<SV, A, J> as Service<Request<J>>>::Response, <AckService<SV, A, J> as Service<Request<J>>>::Error>> + Send>>

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: Request<J>) -> Self::Future

Process the request and return the response asynchronously.

impl<S, T, Req> Service<Request<Req>> for AddExtension<S, T>

where S: Service<Request<Req>>, T: Clone + Send + Sync + 'static,

type Response = <S as Service<Request<Req>>>::Response

Responses given by the service.

type Error = <S as Service<Request<Req>>>::Error

Errors produced by the service.

type Future = <S as Service<Request<Req>>>::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: Request<Req>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Req, E, R> Service<Request<Req>> for ServiceFn<T, ()>

where T: FnMut(Req) -> F, F: Future, F::Output: IntoResponse<Result = Result<R, E>>,

type Response = R

Responses given by the service.

type Error = E

Errors produced by the service.

type Future = Map<F, fn(_: <F as Future>::Output) -> Result<R, E>>

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, task: Request<Req>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Req, E, R, A1, A2> Service<Request<Req>> for ServiceFn<T, (A1, A2)>

where T: FnMut(Req, A1, A2) -> F, F: Future, F::Output: IntoResponse<Result = Result<R, E>>, A1: FromData, A2: FromData,

type Response = R

Responses given by the service.

type Error = E

Errors produced by the service.

type Future = Map<F, fn(_: <F as Future>::Output) -> Result<R, E>>

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, task: Request<Req>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Req, E, R, A1, A2, A3> Service<Request<Req>> for ServiceFn<T, (A1, A2, A3)>

where T: FnMut(Req, A1, A2, A3) -> F, F: Future, F::Output: IntoResponse<Result = Result<R, E>>, A1: FromData, A2: FromData, A3: FromData,

type Response = R

Responses given by the service.

type Error = E

Errors produced by the service.

type Future = Map<F, fn(_: <F as Future>::Output) -> Result<R, E>>

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, task: Request<Req>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Req, E, R, A1, A2, A3, A4> Service<Request<Req>> for ServiceFn<T, (A1, A2, A3, A4)>

where T: FnMut(Req, A1, A2, A3, A4) -> F, F: Future, F::Output: IntoResponse<Result = Result<R, E>>, A1: FromData, A2: FromData, A3: FromData, A4: FromData,

type Response = R

Responses given by the service.

type Error = E

Errors produced by the service.

type Future = Map<F, fn(_: <F as Future>::Output) -> Result<R, E>>

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, task: Request<Req>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Req, E, R, A1, A2, A3, A4, A5> Service<Request<Req>> for ServiceFn<T, (A1, A2, A3, A4, A5)>

where T: FnMut(Req, A1, A2, A3, A4, A5) -> F, F: Future, F::Output: IntoResponse<Result = Result<R, E>>, A1: FromData, A2: FromData, A3: FromData, A4: FromData, A5: FromData,

type Response = R

Responses given by the service.

type Error = E

Errors produced by the service.

type Future = Map<F, fn(_: <F as Future>::Output) -> Result<R, E>>

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, task: Request<Req>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Req, E, R, A1, A2, A3, A4, A5, A6> Service<Request<Req>> for ServiceFn<T, (A1, A2, A3, A4, A5, A6)>

where T: FnMut(Req, A1, A2, A3, A4, A5, A6) -> F, F: Future, F::Output: IntoResponse<Result = Result<R, E>>, A1: FromData, A2: FromData, A3: FromData, A4: FromData, A5: FromData, A6: FromData,

type Response = R

Responses given by the service.

type Error = E

Errors produced by the service.

type Future = Map<F, fn(_: <F as Future>::Output) -> Result<R, E>>

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, task: Request<Req>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Req, E, R, A1, A2, A3, A4, A5, A6, A7> Service<Request<Req>> for ServiceFn<T, (A1, A2, A3, A4, A5, A6, A7)>

where T: FnMut(Req, A1, A2, A3, A4, A5, A6, A7) -> F, F: Future, F::Output: IntoResponse<Result = Result<R, E>>, A1: FromData, A2: FromData, A3: FromData, A4: FromData, A5: FromData, A6: FromData, A7: FromData,

type Response = R

Responses given by the service.

type Error = E

Errors produced by the service.

type Future = Map<F, fn(_: <F as Future>::Output) -> Result<R, E>>

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, task: Request<Req>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Req, E, R, A1, A2, A3, A4, A5, A6, A7, A8> Service<Request<Req>> for ServiceFn<T, (A1, A2, A3, A4, A5, A6, A7, A8)>

where T: FnMut(Req, A1, A2, A3, A4, A5, A6, A7, A8) -> F, F: Future, F::Output: IntoResponse<Result = Result<R, E>>, A1: FromData, A2: FromData, A3: FromData, A4: FromData, A5: FromData, A6: FromData, A7: FromData, A8: FromData,

type Response = R

Responses given by the service.

type Error = E

Errors produced by the service.

type Future = Map<F, fn(_: <F as Future>::Output) -> Result<R, E>>

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, task: Request<Req>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Req, E, R, A1, A2, A3, A4, A5, A6, A7, A8, A9> Service<Request<Req>> for ServiceFn<T, (A1, A2, A3, A4, A5, A6, A7, A8, A9)>

where T: FnMut(Req, A1, A2, A3, A4, A5, A6, A7, A8, A9) -> F, F: Future, F::Output: IntoResponse<Result = Result<R, E>>, A1: FromData, A2: FromData, A3: FromData, A4: FromData, A5: FromData, A6: FromData, A7: FromData, A8: FromData, A9: FromData,

type Response = R

Responses given by the service.

type Error = E

Errors produced by the service.

type Future = Map<F, fn(_: <F as Future>::Output) -> Result<R, E>>

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, task: Request<Req>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Req, E, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> Service<Request<Req>> for ServiceFn<T, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>

where T: FnMut(Req, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) -> F, F: Future, F::Output: IntoResponse<Result = Result<R, E>>, A1: FromData, A2: FromData, A3: FromData, A4: FromData, A5: FromData, A6: FromData, A7: FromData, A8: FromData, A9: FromData, A10: FromData,

type Response = R

Responses given by the service.

type Error = E

Errors produced by the service.

type Future = Map<F, fn(_: <F as Future>::Output) -> Result<R, E>>

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, task: Request<Req>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Req, E, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> Service<Request<Req>> for ServiceFn<T, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)>

where T: FnMut(Req, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) -> F, F: Future, F::Output: IntoResponse<Result = Result<R, E>>, A1: FromData, A2: FromData, A3: FromData, A4: FromData, A5: FromData, A6: FromData, A7: FromData, A8: FromData, A9: FromData, A10: FromData, A11: FromData,

type Response = R

Responses given by the service.

type Error = E

Errors produced by the service.

type Future = Map<F, fn(_: <F as Future>::Output) -> Result<R, E>>

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, task: Request<Req>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Req, E, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> Service<Request<Req>> for ServiceFn<T, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)>

where T: FnMut(Req, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) -> F, F: Future, F::Output: IntoResponse<Result = Result<R, E>>, A1: FromData, A2: FromData, A3: FromData, A4: FromData, A5: FromData, A6: FromData, A7: FromData, A8: FromData, A9: FromData, A10: FromData, A11: FromData, A12: FromData,

type Response = R

Responses given by the service.

type Error = E

Errors produced by the service.

type Future = Map<F, fn(_: <F as Future>::Output) -> Result<R, E>>

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, task: Request<Req>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Req, E, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> Service<Request<Req>> for ServiceFn<T, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)>

where T: FnMut(Req, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) -> F, F: Future, F::Output: IntoResponse<Result = Result<R, E>>, A1: FromData, A2: FromData, A3: FromData, A4: FromData, A5: FromData, A6: FromData, A7: FromData, A8: FromData, A9: FromData, A10: FromData, A11: FromData, A12: FromData, A13: FromData,

type Response = R

Responses given by the service.

type Error = E

Errors produced by the service.

type Future = Map<F, fn(_: <F as Future>::Output) -> Result<R, E>>

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, task: Request<Req>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Req, E, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> Service<Request<Req>> for ServiceFn<T, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)>

where T: FnMut(Req, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) -> F, F: Future, F::Output: IntoResponse<Result = Result<R, E>>, A1: FromData, A2: FromData, A3: FromData, A4: FromData, A5: FromData, A6: FromData, A7: FromData, A8: FromData, A9: FromData, A10: FromData, A11: FromData, A12: FromData, A13: FromData, A14: FromData,

type Response = R

Responses given by the service.

type Error = E

Errors produced by the service.

type Future = Map<F, fn(_: <F as Future>::Output) -> Result<R, E>>

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, task: Request<Req>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Req, E, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> Service<Request<Req>> for ServiceFn<T, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)>

where T: FnMut(Req, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) -> F, F: Future, F::Output: IntoResponse<Result = Result<R, E>>, A1: FromData, A2: FromData, A3: FromData, A4: FromData, A5: FromData, A6: FromData, A7: FromData, A8: FromData, A9: FromData, A10: FromData, A11: FromData, A12: FromData, A13: FromData, A14: FromData, A15: FromData,

type Response = R

Responses given by the service.

type Error = E

Errors produced by the service.

type Future = Map<F, fn(_: <F as Future>::Output) -> Result<R, E>>

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, task: Request<Req>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Req, E, R, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> Service<Request<Req>> for ServiceFn<T, (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)>

where T: FnMut(Req, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) -> F, F: Future, F::Output: IntoResponse<Result = Result<R, E>>, A1: FromData, A2: FromData, A3: FromData, A4: FromData, A5: FromData, A6: FromData, A7: FromData, A8: FromData, A9: FromData, A10: FromData, A11: FromData, A12: FromData, A13: FromData, A14: FromData, A15: FromData, A16: FromData,

type Response = R

Responses given by the service.

type Error = E

Errors produced by the service.

type Future = Map<F, fn(_: <F as Future>::Output) -> Result<R, E>>

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, task: Request<Req>) -> Self::Future

Process the request and return the response asynchronously.

impl<T, F, Req, E, R, A> Service<Request<Req>> for ServiceFn<T, A>

where T: FnMut(Req, A) -> F, F: Future, F::Output: IntoResponse<Result = Result<R, E>>, A: FromData,

type Response = R

Responses given by the service.

type Error = E

Errors produced by the service.

type Future = Map<F, fn(_: <F as Future>::Output) -> Result<R, E>>

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, task: Request<Req>) -> Self::Future

Process the request and return the response asynchronously.