Struct AfterStart 

pub struct AfterStart<B, FutErr> { /* private fields */ }

A hook that runs after a backend has started.

AfterStart allows an asynchronous callback to perform initialization or other work on the backend after it has started.

The callback receives a mutable reference to the backend and must return a future resolving to Result<(), B::Error>.

Implementations

impl<B: Backend> AfterStart<B, B::Error>

pub fn new<F, Fut>(backend: B, f: F) -> Self

where F: Fn(&mut B) -> Fut + 'static + Send + Sync, Fut: Future<Output = Result<(), B::Error>> + Send + 'static,

Creates a new AfterStart hook.

The provided function is called with a mutable reference to the backend after it has started.

Errors

If the callback returns an error, the error is propagated to the backend lifecycle.

Trait Implementations

impl<B> Backend for AfterStart<B, B::Error>

where B: Backend,

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, FutErr> BackendConfig for AfterStart<B, FutErr>

where B: BackendConfig,

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, FutErr> Clone for AfterStart<B, FutErr>

where B: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<B, FutErr> Debug for AfterStart<B, FutErr>

where B: Debug,

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

Formats the value using the given formatter.

impl<B, FutErr> Deref for AfterStart<B, FutErr>

type Target = B

The resulting type after dereferencing.

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

Dereferences the value.

impl<B, FutErr> DerefMut for AfterStart<B, FutErr>

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

Mutably dereferences the value.

impl<B> FetchById for AfterStart<B, B::Error>

where B: FetchById + Backend + Send, B::Task: 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> ListAllTasks for AfterStart<B, B::Error>

where B: ListAllTasks + Send + Sync + Backend,

async fn list_all_tasks( &self, filter: &Filter, ) -> Result<Vec<Task<Self::Compact>>, Self::Error>

List tasks matching the given filter in all queues

impl<B> ListQueues for AfterStart<B, B::Error>

where B: ListQueues + Send + Sync + Backend,

async fn list_queues(&self) -> Result<Vec<QueueInfo>, Self::Error>

List all available queues in the backend

impl<B> ListTasks for AfterStart<B, B::Error>

where B: ListTasks + Send + Sync + Backend,

async fn list_tasks( &self, filter: &Filter, ) -> Result<Vec<Task<Self::Compact>>, Self::Error>

List tasks matching the given filter in the current queue

impl<B> ListWorkers for AfterStart<B, B::Error>

where B: ListWorkers + Send + Sync + Backend,

async fn list_workers(&self) -> Result<Vec<RunningWorker>, Self::Error>

List all registered workers in the current queue

async fn list_all_workers(&self) -> Result<Vec<RunningWorker>, Self::Error>

List all registered workers in all queues

impl<B> Metrics for AfterStart<B, B::Error>

where B: Metrics + Send + Sync + Backend,

async fn global(&self) -> Result<Vec<Statistic>, Self::Error>

Collects and returns global statistics from the backend

async fn fetch_by_queue(&self) -> Result<Vec<Statistic>, Self::Error>

Collects and returns statistics for a specific queue

impl<B> RegisterWorker for AfterStart<B, B::Error>

where B: RegisterWorker + Backend + Send,

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

Registers a worker

impl<B> Reschedule for AfterStart<B, B::Error>

where B: Reschedule + Backend + Send, B::Task: 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 AfterStart<B, B::Error>

where B: ResumeAbandoned + Backend + Send,

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

Resume all abandoned tasks

impl<B> ResumeById for AfterStart<B, B::Error>

where B: ResumeById + Backend + Send,

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

Resume a task by its ID

impl<B, FutErr, T, Err> Sink<T> for AfterStart<B, FutErr>

where B: Sink<T, Error = Err> + Unpin, FutErr: Unpin,

type Error = Err

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

fn start_send(self: Pin<&mut Self>, item: T) -> 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 AfterStart<B, B::Error>

where B: Update + Send + Backend, B::Task: Send,

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

Update the given task

impl<B> Vacuum for AfterStart<B, B::Error>

where B: Vacuum + Backend + 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 AfterStart<B, B::Error>

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

type ResultStream = Pin<Box<dyn Stream<Item = Result<TaskResult<Output>, <AfterStart<B, <B as Backend>::Error> 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, FutErr> WireFormatBackend for AfterStart<B, FutErr>

where B: WireFormatBackend,

type Compact = <B as WireFormatBackend>::Compact

The compact representation of task arguments.

type Codec = <B as WireFormatBackend>::Codec

The codec used to encode and decode tasks.

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

Returns a reference to the codec used by the backend.