Struct QueueManager 

pub struct QueueManager { /* private fields */ }

High-level queue manager providing the public API.

Create a QueueManager, add jobs to it, then call spawn() to start the background executor that processes them.

Example

let config = QueueConfig::builder()
    .with_db_path(PathBuf::from("queue.db"))
    .build();

let manager = QueueManager::new(config).unwrap();
let job = QueueJob::new(MyJob { ... });
manager.add(job).unwrap();

manager.spawn::<MyJob>(Arc::new(LoggingEventEmitter));

Implementations

impl QueueManager

pub fn new(config: QueueConfig) -> Result<QueueManager, QueueError>

Create a new queue manager with the given configuration.

Opens (or creates) the SQLite database and requeues any jobs that were interrupted by a previous crash.

pub fn add<H>(&self, job: QueueJob<H>) -> Result<String, QueueError>

where H: JobHandler,

Add a job to the queue. Returns the job ID.

pub fn cancel(&self, job_id: &str) -> Result<(), QueueError>

Cancel a pending or processing job by ID.

pub fn reorder( &self, job_id: &str, new_priority: QueuePriority, ) -> Result<(), QueueError>

Reorder a pending job to a new priority.

pub fn pause(&self)

Pause the queue. The current job will finish, but no new jobs start.

pub fn resume(&self)

Resume the queue after a pause.

pub fn is_paused(&self) -> bool

Check if the queue is currently paused.

pub fn list_jobs(&self) -> Result<Vec<(String, String)>, QueueError>

Get all jobs as (id, status) pairs, ordered by status then priority.

pub fn list_jobs_with_data( &self, ) -> Result<Vec<(String, String, String)>, QueueError>

Get all jobs as (id, status, data_json) tuples.

pub fn get_job_details( &self, job_id: &str, ) -> Result<Option<QueueJobDetails>, QueueError>

Fetch a structured view of a single job for debugging or UI inspection.

pub fn prune(&self, days: u32) -> Result<u32, QueueError>

Prune completed/failed/cancelled jobs older than days. Returns the number of jobs deleted.

pub async fn process_one<H>( &self, event_emitter: &Arc<dyn QueueEventEmitter>, ) -> Result<Option<ProcessedJob>, QueueError>

where H: JobHandler,

Process the next pending job in the foreground and return the result.

Returns Ok(None) if no pending jobs are available. Unlike spawn(), this does not start a background loop — it processes exactly one job and returns. Useful for CLI-driven loops where cascade logic runs between jobs.

pub fn count_by_status(&self) -> Result<QueueStats, QueueError>

Count jobs by status.

pub fn shutdown(&self)

Signal the executor to shut down gracefully.

The currently running job (if any) will finish, then the background loop exits. This is safe to call multiple times.

pub fn is_shutdown(&self) -> bool

Check if a shutdown has been requested.

pub fn worker_id(&self) -> &str

Returns the configured worker identifier.

pub fn spawn<H>( self, event_emitter: Arc<dyn QueueEventEmitter>, ) -> Arc<QueueManager>

where H: JobHandler + 'static,

Spawn the background executor and return the manager wrapped in an Arc.

The event emitter receives notifications about job lifecycle events.

If the current thread is inside a tokio runtime, the executor loop is spawned directly. Otherwise (e.g., during Tauri’s synchronous setup() phase), a dedicated background thread is created automatically.

pub fn spawn_on<H>( self, event_emitter: Arc<dyn QueueEventEmitter>, handle: &Handle, ) -> Arc<QueueManager>

where H: JobHandler + 'static,

Spawn the background executor on a specific tokio runtime handle.

Use this instead of spawn() when you have an explicit runtime handle (e.g., from tauri::async_runtime::handle()).