Enum StorageInstance

pub enum StorageInstance {
    Memory(MemoryStorage),
}

Storage instance that can hold any storage implementation

Variants

Memory(MemoryStorage)

Memory storage instance

Implementations

impl StorageInstance

pub async fn from_config(config: StorageConfig) -> Result<Self, StorageError>

Create a storage instance from configuration

Arguments

• config - The storage configuration

Returns

• Ok(storage) - The created storage instance
• Err(StorageError) - If there was an error creating the storage

Examples

use qml_rs::storage::{StorageInstance, StorageConfig, MemoryConfig};

let config = StorageConfig::Memory(MemoryConfig::default());
let storage = StorageInstance::from_config(config).await.unwrap();

pub fn memory() -> Self

Create a memory storage instance with default configuration

Examples

use qml_rs::storage::StorageInstance;

let storage = StorageInstance::memory();

pub fn memory_with_config(config: MemoryConfig) -> Self

Create a memory storage instance with custom configuration

Arguments

• config - The memory storage configuration

Examples

use qml_rs::storage::{StorageInstance, MemoryConfig};

let config = MemoryConfig::new().with_max_jobs(1000);
let storage = StorageInstance::memory_with_config(config);

Trait Implementations

impl Storage for StorageInstance

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.