Struct AppState 

pub struct AppState {

    pub gpu_pool: Arc<GpuPool>,
    pub queue_capacity: usize,
    pub model_cache: Arc<Mutex<ModelCache>>,
    pub active_generation: Arc<RwLock<Option<ActiveGenerationSnapshot>>>,
    pub config: Arc<RwLock<Config>>,
    pub start_time: Instant,
    pub model_load_lock: Arc<Mutex<()>>,
    pub pull_lock: Arc<Mutex<()>>,
    pub queue: QueueHandle,
    pub job_registry: SharedJobRegistry,
    pub queue_pause: Arc<QueuePause>,
    pub shared_pool: Arc<Mutex<SharedPool>>,
    pub shutdown_tx: Arc<Mutex<Option<Sender<()>>>>,
    pub upscaler_cache: Arc<Mutex<Option<Box<dyn UpscaleEngine>>>>,
    pub metadata_db: Arc<Option<MetadataDb>>,
    pub chain_jobs: Option<Arc<ChainJobRunnerHandle>>,
    pub downloads: Arc<DownloadQueue>,
    pub resources: Arc<ResourceBroadcaster>,
    pub events: Arc<EventBroadcaster>,
    pub catalog_live_cache: LiveCache,
    pub catalog_live_civitai_base: Arc<String>,
    pub catalog_intents: Arc<RwLock<HashMap<String, CatalogModelIntent>>>,
}

Fields

gpu_pool: Arc<GpuPool>

GPU worker pool for multi-GPU dispatch.

queue_capacity: usize

Maximum queue capacity (for status reporting and 503 responses).

model_cache: Arc<Mutex<ModelCache>>

active_generation: Arc<RwLock<Option<ActiveGenerationSnapshot>>>

Uses std::sync::RwLock (not tokio) because it’s only accessed from synchronous contexts (inside spawn_blocking closures and brief reads). Must never be held across an .await point.

config: Arc<RwLock<Config>>

start_time: Instant

model_load_lock: Arc<Mutex<()>>

Guards concurrent model loads and hot-swaps.

pull_lock: Arc<Mutex<()>>

Guards concurrent pulls — only one download at a time.

queue: QueueHandle

Generation request queue.

job_registry: SharedJobRegistry

Authoritative registry of in-flight jobs (queued + running). Powers GET /api/queue so the SPA can reconcile persisted “running” cards against server reality and dead-letter zombies whose SSE stream silently dropped.

queue_pause: Arc<QueuePause>

Dispatch pause gate toggled by POST /api/queue/pause / POST /api/queue/resume. The dispatch loops park on this at the top of each iteration; a job already running on a worker finishes untouched.

shared_pool: Arc<Mutex<SharedPool>>

Shared tokenizer pool for cross-engine caching.

shutdown_tx: Arc<Mutex<Option<Sender<()>>>>

Shutdown trigger for graceful shutdown via /api/shutdown endpoint.

upscaler_cache: Arc<Mutex<Option<Box<dyn UpscaleEngine>>>>

Cached upscaler engine to avoid recreating per request. Small models (2-64MB), single slot.

metadata_db: Arc<Option<MetadataDb>>

SQLite-backed gallery metadata store. None when MOLD_DB_DISABLE=1 or when MOLD_HOME could not be resolved — callers must fall back to the filesystem walk in routes::scan_gallery_dir.

chain_jobs: Option<Arc<ChainJobRunnerHandle>>

Durable chain-job runner handle. None when DB-backed chain jobs are unavailable; chain-job API handlers return 503 in that state.

downloads: Arc<DownloadQueue>

Bounded-parallel download queue.

resources: Arc<ResourceBroadcaster>

Always-on resource telemetry (Agent B).

events: Arc<EventBroadcaster>

Server-wide lifecycle broadcast backing GET /api/events — job queued/started/ended (mirrored by job_registry) plus gallery added/removed. One SSE connection observes the whole server.

catalog_live_cache: LiveCache

In-process TTL cache backing /api/catalog/search.

catalog_live_civitai_base: Arc<String>

Upstream base URL for live Civitai search. Production runs with the public host; tests override via with_civitai_base.

catalog_intents: Arc<RwLock<HashMap<String, CatalogModelIntent>>>

Cache of pure synthesis intents for installed catalog (cv:*/hf:*) IDs, keyed by ID. Resolution into a ModelConfig is deferred to engine-load time so disk-state races (file present vs not) can’t seal a wrong config; see model_manager::resolve_intent_to_paths.

Implementations

impl AppState

pub fn new( engine: Box<dyn InferenceEngine>, config: Config, queue: QueueHandle, gpu_pool: Arc<GpuPool>, queue_capacity: usize, ) -> Self

Create state with a pre-loaded engine (server starts with a configured model).

pub fn empty( config: Config, queue: QueueHandle, gpu_pool: Arc<GpuPool>, queue_capacity: usize, ) -> Self

Create state with no engine (zero-config startup, models pulled on demand).

pub fn for_tests() -> Self

Construct an empty AppState for integration tests. Catalog surfaces hit live HF/Civitai (test callers point those at a wiremock instance via with_civitai_base).

pub fn with_civitai_base(self, base: impl Into<String>) -> Self

Override the live-search Civitai base URL on an existing state. Tests point this at a wiremock instance; production never calls it (the new / empty constructors set the public host).

Trait Implementations

impl Clone for AppState

fn clone(&self) -> AppState

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.