Trait Backend 

pub trait Backend {
    type Args;
    type IdType: Clone;
    type Context: Default;
    type Error;
    type Codec: Codec<Self::Args, Compact = Self::Compact>;
    type Compact;
    type Stream: Stream<Item = Result<Option<Task<Self::Args, Self::Context, Self::IdType>>, Self::Error>>;
    type Beat: Stream<Item = Result<(), Self::Error>>;
    type Layer;

    // Required methods
    fn heartbeat(&self, worker: &WorkerContext) -> Self::Beat;
    fn middleware(&self) -> Self::Layer;
    fn poll(self, worker: &WorkerContext) -> Self::Stream;
}

The Backend trait defines how workers get and manage tasks from a backend.

In other languages, this might be called a “Queue”, “Broker”, etc.

Required Associated Types

type Args

The type of arguments the backend handles.

type IdType: Clone

The type used to uniquely identify tasks.

type Context: Default

Context associated with each task.

type Error

The error type returned by backend operations

type Codec: Codec<Self::Args, Compact = Self::Compact>

The codec used for serialization/deserialization of tasks.

type Compact

The compact representation of task arguments.

type Stream: Stream<Item = Result<Option<Task<Self::Args, Self::Context, Self::IdType>>, Self::Error>>

A stream of tasks provided by the backend.

type Beat: Stream<Item = Result<(), Self::Error>>

A stream representing heartbeat signals.

type Layer

The type representing backend middleware layer.

Required Methods

fn heartbeat(&self, worker: &WorkerContext) -> Self::Beat

Returns a heartbeat stream for the given worker.

fn middleware(&self) -> Self::Layer

Returns the backend’s middleware layer.

fn poll(self, worker: &WorkerContext) -> Self::Stream

Polls the backend for tasks for the given worker.

Implementors

impl<Args> Backend for JsonStorage<Args>

where Args: 'static + Send + Serialize + DeserializeOwned + Unpin,

Available on crate feature json only.

type Args = Args

type IdType = RandomId

type Error = SendError

type Context = Map<String, Value>

type Stream = Pin<Box<dyn Stream<Item = Result<Option<Task<Args, Map<String, Value>>>, SendError>> + Send>>

type Layer = AcknowledgeLayer<JsonAck<Args>>

type Beat = Pin<Box<dyn Stream<Item = Result<(), <JsonStorage<Args> as Backend>::Error>> + Send>>

type Codec = JsonCodec<Value>

type Compact = Value

impl<Args, Ctx, S, TSink, Err> Backend for Pipe<S, TSink, Args, Ctx>

where S: Stream<Item = Result<Args, Err>> + Send + 'static, TSink: Backend<Args = Args, Context = Ctx> + TaskSink<Args> + Clone + Unpin + Send + 'static + Sink<Task<TSink::Compact, Ctx, TSink::IdType>>, <TSink as Backend>::Error: Error + Send + Sync + 'static, TSink::Beat: Send + 'static, TSink::IdType: Send + Clone + 'static, TSink::Stream: Send + 'static, Args: Send + 'static, Ctx: Send + 'static + Default, Err: Error + Send + Sync + 'static, <TSink as Sink<Task<TSink::Compact, Ctx, TSink::IdType>>>::Error: Error + Send + Sync + 'static, <<TSink as Backend>::Codec as Codec<Args>>::Error: Error + Send + Sync + 'static, TSink::Compact: Send,

type Args = Args

type IdType = <TSink as Backend>::IdType

type Context = Ctx

type Stream = Pin<Box<dyn Stream<Item = Result<Option<Task<Args, Ctx, <Pipe<S, TSink, Args, Ctx> as Backend>::IdType>>, PipeError>> + Send>>

type Layer = <TSink as Backend>::Layer

type Beat = Pin<Box<dyn Stream<Item = Result<(), PipeError>> + Send>>

type Error = PipeError

type Codec = <TSink as Backend>::Codec

type Compact = <TSink as Backend>::Compact

impl<Args, DB, Fetch, Sink, IdType: Clone, E, Ctx: Default, Encode, Config> Backend for CustomBackend<Args, DB, Fetch, Sink, IdType, Encode, Config>

where Fetch: Stream<Item = Result<Option<Task<Encode::Compact, Ctx, IdType>>, E>> + Send + 'static, Encode: Codec<Args> + Send + 'static, Encode::Error: Into<BoxDynError>, E: Into<BoxDynError>,

type Args = Args

type IdType = IdType

type Context = Ctx

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

type Stream = Pin<Box<dyn Stream<Item = Result<Option<Task<Args, Ctx, IdType>>, Box<dyn Error + Send + Sync>>> + Send>>

type Codec = Encode

type Compact = <Encode as Codec<Args>>::Compact

type Beat = Pin<Box<dyn Stream<Item = Result<(), <CustomBackend<Args, DB, Fetch, Sink, IdType, Encode, Config> as Backend>::Error>> + Send>>

type Layer = Identity

impl<Args: 'static + Clone + Send, Ctx: 'static + Default> Backend for MemoryStorage<Args, Ctx>

type Args = Args

type IdType = RandomId

type Context = Ctx

type Error = SendError

type Stream = Pin<Box<dyn Stream<Item = Result<Option<Task<Args, Ctx>>, SendError>> + Send>>

type Layer = Identity

type Beat = Pin<Box<dyn Stream<Item = Result<(), <MemoryStorage<Args, Ctx> as Backend>::Error>> + Send>>

type Codec = IdentityCodec

type Compact = Args