Struct Shared 

pub struct Shared<B: WireFormatBackend> { /* private fields */ }

Available on crate feature shared only.

Create a cloneable handle to the inner backend where all handles are clone.

Implementations

impl<B: WireFormatBackend> Shared<B>

where B::Codec: Clone,

pub fn new(backend: B) -> Self

Build a new Sharable backend

Trait Implementations

impl<B> Backend for Shared<B>

where B: Backend + WireFormatBackend,

type Task = <B as Backend>::Task

The type of task the backend emits.

type Error = <B as Backend>::Error

The error type returned by backend operations

fn poll_ready( &mut self, cx: &mut Context<'_>, worker: &WorkerContext, ) -> Poll<Result<(), Self::Error>>

Polls whether the backend is ready for the worker to request more work.

fn poll_next( &mut self, cx: &mut Context<'_>, worker: &WorkerContext, ) -> Poll<Option<Result<Self::Task, Self::Error>>>

Polls the backend for the next available task for this worker.

fn poll_close( &mut self, cx: &mut Context<'_>, worker: &WorkerContext, ) -> Poll<Result<(), Self::Error>>

Flushes/releases any resources the backend holds (pending acks, open subscriptions, connections) before the worker fully shuts down.

impl<B> BackendConfig for Shared<B>

where B: BackendConfig + WireFormatBackend,

type Id = <B as BackendConfig>::Id

The internal type of this Backend’s TaskId

type Args = <B as BackendConfig>::Args

The type of argument this backend emits

type Kind = <B as BackendConfig>::Kind

This defines the kind of Backend

type Config = <B as BackendConfig>::Config

The config for the backend

type Layer = <B as BackendConfig>::Layer

The type representing backend middleware layer.

fn config(&self) -> &Self::Config

Returns the config associated with the backend.

fn middleware(&mut self, worker: &mut WorkerContext) -> Self::Layer

Returns the backend’s middleware layer.

impl<B> Clone for Shared<B>

where B::Codec: Clone, B: WireFormatBackend,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<B: Debug + WireFormatBackend> Debug for Shared<B>

where B::Codec: Debug, B::Compact: Debug,

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

Formats the value using the given formatter.

impl<B: WireFormatBackend> Drop for Shared<B>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<B> FetchById for Shared<B>

where B: FetchById + Backend + WireFormatBackend + Send, B::Task: Send, B::Codec: Send, B::Compact: Send,

async fn fetch_by_id( &mut self, task_id: &TaskId, ) -> Result<Option<B::Task>, Self::Error>

Fetch a task by its unique identifier

impl<B> RegisterWorker for Shared<B>

where B: RegisterWorker + Backend + WireFormatBackend + Send, B::Codec: Send, B::Compact: Send,

async fn register_worker( &mut self, worker_id: String, ) -> Result<(), Self::Error>

Registers a worker

impl<B> Reschedule for Shared<B>

where B: Reschedule + Backend + WireFormatBackend + Send, B::Task: Send, B::Codec: Send, B::Compact: Send,

async fn reschedule( &mut self, task: Self::Task, wait: Duration, ) -> Result<(), Self::Error>

Reschedule the task after a specified duration

impl<B> ResumeAbandoned for Shared<B>

where B: ResumeAbandoned + Backend + WireFormatBackend + Send, B::Codec: Send, B::Compact: Send,

async fn resume_abandoned(&mut self) -> Result<usize, Self::Error>

Resume all abandoned tasks

impl<B> ResumeById for Shared<B>

where B: ResumeById + Backend + WireFormatBackend + Send, B::Codec: Send, B::Compact: Send,

async fn resume_by_id(&mut self, id: TaskId) -> Result<bool, Self::Error>

Resume a task by its ID

impl<B, Err> Sink<Task<<B as WireFormatBackend>::Compact>> for Shared<B>

where B: Backend<Error = Err> + Sink<Task<B::Compact>, Error = Err> + Unpin + WireFormatBackend, B::Codec: Unpin, B::Compact: Unpin,

type Error = Err

The type of value produced by the sink when an error occurs.

fn start_send( self: Pin<&mut Self>, item: Task<B::Compact>, ) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_ready( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

fn poll_flush( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output from this sink.

fn poll_close( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output and close this sink, if necessary.

impl<B> Update for Shared<B>

where B: Update + Send + Backend + WireFormatBackend, B::Task: Send, B::Codec: Send, B::Compact: Send,

async fn update(&mut self, task: Self::Task) -> Result<(), Self::Error>

Update the given task

impl<B> Vacuum for Shared<B>

where B: Vacuum + Backend + WireFormatBackend + Send, B::Codec: Send, B::Compact: Send,

async fn vacuum(&mut self) -> Result<usize, Self::Error>

Cleans up all resources and returns the number of tasks vacuumed

async fn vacuum_before( &mut self, duration: Duration, ) -> Result<usize, Self::Error>

Cleans up all resources committed before a specific duration and returns the number of tasks vacuumed

impl<Output, B> WaitForCompletion<Output> for Shared<B>

where B: WaitForCompletion<Output> + Sync + 'static + Backend + WireFormatBackend + Send, Output: Send + 'static, B::Codec: Sync + Send, B::Compact: Send + Sync,

type ResultStream = Pin<Box<dyn Stream<Item = Result<TaskResult<Output>, <Shared<B> as Backend>::Error>> + Send>>

The result stream type yielding task results

fn wait_for( &mut self, task_ids: impl IntoIterator<Item = TaskId>, ) -> Self::ResultStream

Wait for multiple tasks to complete, yielding results as they become available

async fn check_status( &mut self, task_ids: impl IntoIterator<Item = TaskId> + Send, ) -> Result<Vec<TaskResult<Output>>, Self::Error>

Check current status of tasks without waiting

fn wait_for_single(&mut self, task_id: TaskId) -> Self::ResultStream

Wait for a single task to complete, yielding its result

impl<B: WireFormatBackend> WireFormatBackend for Shared<B>

type Codec = <B as WireFormatBackend>::Codec

The codec used to encode and decode tasks.

type Compact = <B as WireFormatBackend>::Compact

The compact representation of task arguments.

fn codec(&self) -> &Self::Codec

Returns a reference to the codec used by the backend.