Trait Middleware

pub trait Middleware<M: Metadata>:
    Send
    + Sync
    + 'static {
    type Future: Future<Item = Option<Response>, Error = ()> + Send + 'static;
    type CallFuture: Future<Item = Option<Output>, Error = ()> + Send + 'static;

    // Provided methods
    fn on_request<F, X>(
        &self,
        request: Request,
        meta: M,
        next: F,
    ) -> Either<Self::Future, X>
       where F: FnOnce(Request, M) -> X + Send,
             X: Future<Item = Option<Response>, Error = ()> + Send + 'static { ... }
    fn on_call<F, X>(
        &self,
        call: Call,
        meta: M,
        next: F,
    ) -> Either<Self::CallFuture, X>
       where F: FnOnce(Call, M) -> X + Send,
             X: Future<Item = Option<Output>, Error = ()> + Send + 'static { ... }
}

RPC middleware

Required Associated Types

type Future: Future<Item = Option<Response>, Error = ()> + Send + 'static

A returned request future.

type CallFuture: Future<Item = Option<Output>, Error = ()> + Send + 'static

A returned call future.

Provided Methods

fn on_request<F, X>( &self, request: Request, meta: M, next: F, ) -> Either<Self::Future, X>

where F: FnOnce(Request, M) -> X + Send, X: Future<Item = Option<Response>, Error = ()> + Send + 'static,

Method invoked on each request. Allows you to either respond directly (without executing RPC call) or do any additional work before and/or after processing the request.

fn on_call<F, X>( &self, call: Call, meta: M, next: F, ) -> Either<Self::CallFuture, X>

where F: FnOnce(Call, M) -> X + Send, X: Future<Item = Option<Output>, Error = ()> + Send + 'static,

Method invoked on each call inside a request.

Allows you to either handle the call directly (without executing RPC call).

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<M: Metadata, A: Middleware<M>, B: Middleware<M>> Middleware<M> for (A, B)

type Future = Either<<A as Middleware<M>>::Future, <B as Middleware<M>>::Future>

type CallFuture = Either<<A as Middleware<M>>::CallFuture, <B as Middleware<M>>::CallFuture>

fn on_request<F, X>( &self, request: Request, meta: M, process: F, ) -> Either<Self::Future, X>

where F: FnOnce(Request, M) -> X + Send, X: Future<Item = Option<Response>, Error = ()> + Send + 'static,

fn on_call<F, X>( &self, call: Call, meta: M, process: F, ) -> Either<Self::CallFuture, X>

where F: FnOnce(Call, M) -> X + Send, X: Future<Item = Option<Output>, Error = ()> + Send + 'static,

impl<M: Metadata, A: Middleware<M>, B: Middleware<M>, C: Middleware<M>> Middleware<M> for (A, B, C)

type Future = Either<<A as Middleware<M>>::Future, Either<<B as Middleware<M>>::Future, <C as Middleware<M>>::Future>>

type CallFuture = Either<<A as Middleware<M>>::CallFuture, Either<<B as Middleware<M>>::CallFuture, <C as Middleware<M>>::CallFuture>>

fn on_request<F, X>( &self, request: Request, meta: M, process: F, ) -> Either<Self::Future, X>

where F: FnOnce(Request, M) -> X + Send, X: Future<Item = Option<Response>, Error = ()> + Send + 'static,

fn on_call<F, X>( &self, call: Call, meta: M, process: F, ) -> Either<Self::CallFuture, X>

where F: FnOnce(Call, M) -> X + Send, X: Future<Item = Option<Output>, Error = ()> + Send + 'static,

impl<M: Metadata, A: Middleware<M>, B: Middleware<M>, C: Middleware<M>, D: Middleware<M>> Middleware<M> for (A, B, C, D)

type Future = Either<<A as Middleware<M>>::Future, Either<<B as Middleware<M>>::Future, Either<<C as Middleware<M>>::Future, <D as Middleware<M>>::Future>>>

type CallFuture = Either<<A as Middleware<M>>::CallFuture, Either<<B as Middleware<M>>::CallFuture, Either<<C as Middleware<M>>::CallFuture, <D as Middleware<M>>::CallFuture>>>

fn on_request<F, X>( &self, request: Request, meta: M, process: F, ) -> Either<Self::Future, X>

where F: FnOnce(Request, M) -> X + Send, X: Future<Item = Option<Response>, Error = ()> + Send + 'static,

fn on_call<F, X>( &self, call: Call, meta: M, process: F, ) -> Either<Self::CallFuture, X>

where F: FnOnce(Call, M) -> X + Send, X: Future<Item = Option<Output>, Error = ()> + Send + 'static,

Implementors

impl<M: Metadata> Middleware<M> for Noop

type Future = Box<dyn Future<Item = Option<Response>, Error = ()> + Send>

type CallFuture = Box<dyn Future<Item = Option<Output>, Error = ()> + Send>