Struct QueueManager 

pub struct QueueManager {
    sender: Sender<FileTask>,
    shared_state: Arc<Mutex<AppState>>,
    retry_list: Arc<Mutex<Vec<FileTask>>>,
    pending_paths: Arc<Mutex<HashSet<String>>>,
    retry_path: PathBuf,
    policy: Arc<Mutex<EnvironmentPolicy>>,
    worker_limit: Arc<AtomicUsize>,
    batch_notify_state: Arc<Mutex<BatchNotifyState>>,
    accepting_new: Arc<AtomicBool>,
    shutdown_token: CancellationToken,
}

Fields

sender: Sender<FileTask>

Internal task sender channel.

shared_state: Arc<Mutex<AppState>>

Shared in-memory state accessed by both workers and the UI.

retry_list: Arc<Mutex<Vec<FileTask>>>

Failed tasks accumulated in memory and flushed during graceful shutdown.

pending_paths: Arc<Mutex<HashSet<String>>>

Paths already queued or awaiting retry to avoid duplication.

retry_path: PathBuf

Path of persistent retries file.

policy: Arc<Mutex<EnvironmentPolicy>>

Shared current transmission limits and environmental constraints.

worker_limit: Arc<AtomicUsize>

Active worker concurrency limit wrapper.

batch_notify_state: Arc<Mutex<BatchNotifyState>>

Sync summary notification batch states tracker.

accepting_new: Arc<AtomicBool>

Flag indicating whether new tasks are accepted.

shutdown_token: CancellationToken

Internal shutdown cancellation coordinator.

Implementations

impl QueueManager

pub fn new( api_client: Arc<ImmichApiClient>, workers: usize, shared_state: Arc<Mutex<AppState>>, sync_index: Arc<ShardedSyncIndex>, policy: EnvironmentPolicy, ) -> Self

Initialize a new QueueManager and kick off worker threads.

pub async fn add_to_queue(&self, task: FileTask) -> bool

Add a file task to the upload queue and return whether it was accepted.

pub fn set_paused(&self, paused: bool, reason: Option<String>)

pub fn is_paused(&self) -> bool

pub fn set_worker_limit(&self, workers: u8)

pub fn update_environment_policy(&self, policy: EnvironmentPolicy)

pub fn recent_events(&self) -> Vec<QueueEvent>

pub fn failed_tasks(&self) -> Vec<FileTask>

pub fn clear_failed(&self) -> usize

pub async fn retry_all_failed(&self) -> usize

pub async fn retry_failed_path(&self, path: &str) -> bool

pub async fn shutdown(&self, deadline: Duration)

Stop accepting new tasks, wait up to deadline for active uploads to finish, then hard-cancel anything still in flight.

In-flight uploads that get cancelled at the deadline land in the retry list (treated as failures) so flush_retries will persist them for the next session.

pub fn flush_retries(&self)

Persist any in-memory retry items so they survive a clean shutdown.

async fn requeue_failed(&self, tasks: Vec<FileTask>, detail: String) -> usize

Requeue failed task lists with specified details string.