Struct MemoryStorage

pub struct MemoryStorage { /* private fields */ }

In-memory storage implementation for jobs

This storage keeps all jobs in memory using a HashMap with RwLock for thread safety. It’s primarily intended for development, testing, and simple scenarios where persistence is not required.

Implementations

impl MemoryStorage

pub fn new() -> Self

Create a new memory storage with default configuration

pub fn with_config(config: MemoryConfig) -> Self

Create a new memory storage with the specified configuration

pub fn len(&self) -> usize

Get the number of jobs currently stored

pub fn is_empty(&self) -> bool

Check if the storage is empty

pub fn clear(&self)

Clear all jobs from storage

Trait Implementations

impl Debug for MemoryStorage

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

Formats the value using the given formatter.

impl Default for MemoryStorage

fn default() -> Self

Returns the “default value” for a type.

impl Storage for MemoryStorage

fn enqueue<'life0, 'life1, 'async_trait>( &'life0 self, job: &'life1 Job, ) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Store a new job in the storage backend.

fn get<'life0, 'life1, 'async_trait>( &'life0 self, job_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Job>, StorageError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieve a job by its unique identifier.

fn update<'life0, 'life1, 'async_trait>( &'life0 self, job: &'life1 Job, ) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Update an existing job’s state and metadata.

fn delete<'life0, 'life1, 'async_trait>( &'life0 self, job_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<bool, StorageError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Remove a job from storage (soft or hard delete).

fn list<'life0, 'life1, 'async_trait>( &'life0 self, state_filter: Option<&'life1 JobState>, limit: Option<usize>, offset: Option<usize>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Job>, StorageError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List jobs with optional filtering and pagination.

fn get_job_counts<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<HashMap<JobState, usize>, StorageError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the count of jobs grouped by their current state.

fn get_available_jobs<'life0, 'async_trait>( &'life0 self, limit: Option<usize>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Job>, StorageError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get jobs that are ready to be processed immediately.

fn fetch_and_lock_job<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, worker_id: &'life1 str, queues: Option<&'life2 [String]>, ) -> Pin<Box<dyn Future<Output = Result<Option<Job>, StorageError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Atomically fetch and lock a job for processing to prevent race conditions.

fn try_acquire_job_lock<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, job_id: &'life1 str, worker_id: &'life2 str, timeout_seconds: u64, ) -> Pin<Box<dyn Future<Output = Result<bool, StorageError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Try to acquire an explicit lock on a specific job.

fn release_job_lock<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, job_id: &'life1 str, worker_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<bool, StorageError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Release an explicit lock on a job.

fn fetch_available_jobs_atomic<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, worker_id: &'life1 str, limit: Option<usize>, queues: Option<&'life2 [String]>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Job>, StorageError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Atomically fetch multiple available jobs with locking.