Struct MemoryStorage 

pub struct MemoryStorage<Args> { /* private fields */ }

In-memory queue that is based on channels

Example

let mut backend = MemoryStorage::new();

Features

Feature	Status	Description
Backend	✅	Basic Backend functionality
TaskSink	✅	Ability to push new tasks
Serialization	❌	Serialization support for arguments
PipeExt	⚠️	Allow other backends to pipe to this backend
BackendFactory	❌	Share the same storage across multiple workers
Update	❌	Allow updating a task
FetchById	❌	Allow fetching a task by its ID
Reschedule	❌	Reschedule a task
ResumeById	❌	Resume a task by its ID
ResumeAbandoned	❌	Resume abandoned tasks
Vacuum	❌	Vacuum the task storage
Workflow	⚠️	Flexible enough to support workflows
WaitForCompletion	⚠️	Wait for tasks to complete without blocking
RegisterWorker	❌	Allow registering a worker with the backend
ListWorkers	❌	List all workers registered with the backend
ListTasks	❌	List all tasks in the backend

Key: ✅ : Supported | ⚠️ : Not implemented | ❌ : Not Supported | ❗ Limited support

Tests:

Backend

#[tokio::main]
async fn main() {
    // let mut backend = /* snip */;
    
    async fn task(task: u32, worker: WorkerContext) {
        // Do some work 
    }
    let worker = WorkerBuilder::new("backend-test")
        .backend(backend)
        .build(task);
    let _ = worker.stream().take(1).collect::<Vec<_>>().await;
}

TaskSink

#[tokio::main]
async fn main() {
    // let mut backend = /* snip */;
    
    backend.push(42).await.unwrap();

    async fn task(task: u32, worker: WorkerContext) {
        worker.stop().unwrap();
    }
    let worker = WorkerBuilder::new("task-sink-test")
        .backend(backend)
        .build(task);
    worker.run().await.unwrap();
}

Implementations

impl<Args: Send + 'static> MemoryStorage<Args>

pub fn new() -> Self

Create a new in-memory storage

pub fn new_with(sender: MemorySink<Args>, receiver: BoxedReceiver<Args>) -> Self

Create a storage given a sender and receiver

Trait Implementations

impl<Args> Backend for MemoryStorage<Args>

type Task = Task<Args>

The type of task the backend emits.

type Error = MemoryStorageError

The error type returned by backend operations

fn poll_ready( &mut self, cx: &mut Context<'_>, _: &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<'_>, _: &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<'_>, _: &WorkerContext, ) -> Poll<Result<(), Self::Error>>

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

impl<Args> BackendConfig for MemoryStorage<Args>

type Id = RandomId

The internal type of this Backend’s TaskId

type Args = Args

The type of argument this backend emits

type Kind = Ephemeral

This defines the kind of Backend

type Config = ()

The config for the backend

type Layer = Identity

The type representing backend middleware layer.

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

Returns the config associated with the backend.

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

Returns the backend’s middleware layer.

impl<Args> Debug for MemoryStorage<Args>

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

Formats the value using the given formatter.

impl<Args: Send + 'static> Default for MemoryStorage<Args>

fn default() -> Self

Returns the “default value” for a type.

impl<Args> Sink<Task<Args>> for MemoryStorage<Args>

type Error = MemoryStorageError

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

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

Attempts to prepare the Sink to receive a value.

fn start_send(self: Pin<&mut Self>, item: Task<Args>) -> 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_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<Args> Stream for MemoryStorage<Args>

type Item = Task<Args>

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.

impl<T: Send + 'static> TryNewBackend for MemoryStorage<T>

type Backend = MemoryStorage<T>

The final backend after decoration

fn try_new(_: Self::Config) -> Result<Self::Backend, Self::Error>

Attempt to construct a new backend instance from its configuration.