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 chain_lock: Arc<Mutex<()>>,
    pub queue: QueueHandle,
    pub job_registry: SharedJobRegistry,
    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 downloads: Arc<DownloadQueue>,
    pub resources: Arc<ResourceBroadcaster>,
    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.

chain_lock: Arc<Mutex<()>>

Serializes chained video renders. The chain handler removes the engine from model_cache and runs blocking work outside that lock for the full multi-minute chain; without a dedicated lock two concurrent chain requests race on cache.take() and the loser surfaces “engine vanished from cache after ensure_model_ready”. Held for the entire chain (load + all stages + restore); other single-clip requests continue to queue normally on queue.

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.

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.

downloads: Arc<DownloadQueue>

Single-writer download queue.

resources: Arc<ResourceBroadcaster>

Always-on resource telemetry (Agent B).

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.