Skip to main content

rigspark_runtime/catalog_update/
store.rs

1use super::{
2    CatalogUpdateError, MAX_ARTIFACT_BYTES, SignedCatalog, VerifiedCatalog, decode_hex, verify,
3};
4use crate::secure_fs::Directory;
5use cap_fs_ext::{FollowSymlinks, OpenOptionsFollowExt};
6use rigspark_core::catalog::Catalog;
7use serde::{Deserialize, Serialize};
8use sha2::{Digest, Sha256};
9use std::{
10    io::ErrorKind,
11    path::{Path, PathBuf},
12};
13
14const STATE: &str = "catalog/snapshots.json";
15const MAX_STATE_BYTES: u64 = (MAX_ARTIFACT_BYTES * 3) as u64;
16
17#[derive(Serialize)]
18#[serde(rename_all = "camelCase")]
19pub struct CatalogStatus {
20    pub source: &'static str,
21    pub revision: Option<u64>,
22    pub digest: String,
23    pub generated_at: String,
24    pub published_at: Option<String>,
25    pub model_count: usize,
26    pub updates_configured: bool,
27    pub warnings: Vec<String>,
28}
29
30pub struct LoadedCatalog {
31    pub catalog: Catalog,
32    pub raw: String,
33    pub status: CatalogStatus,
34}
35
36#[derive(Serialize, Deserialize)]
37#[serde(rename_all = "camelCase", deny_unknown_fields)]
38struct Snapshots {
39    version: u8,
40    highest_revision: u64,
41    highest_digest: String,
42    current: SignedCatalog,
43    previous: Option<SignedCatalog>,
44}
45
46pub struct CatalogStore {
47    home: PathBuf,
48    pub(super) key: Option<[u8; 32]>,
49}
50
51impl CatalogStore {
52    pub fn new(home: impl Into<PathBuf>, key: Option<[u8; 32]>) -> Self {
53        Self {
54            home: home.into(),
55            key,
56        }
57    }
58
59    pub fn official(home: impl Into<PathBuf>) -> Self {
60        let key = decode_hex(include_str!("../catalog_public_key.hex").trim()).ok();
61        Self::new(home, key)
62    }
63
64    fn read_state(&self) -> Result<Option<Snapshots>, CatalogUpdateError> {
65        let result = Directory::open(&self.home)
66            .and_then(|directory| directory.read(Path::new(STATE), MAX_STATE_BYTES, false));
67        let bytes = match result {
68            Ok(bytes) => bytes,
69            Err(error) if error.kind() == ErrorKind::NotFound => return Ok(None),
70            Err(error) => return Err(error.into()),
71        };
72        let state: Snapshots = serde_json::from_slice(&bytes)
73            .map_err(|_| CatalogUpdateError::Invalid("cache state"))?;
74        if state.version != 1
75            || state.highest_revision == 0
76            || decode_hex::<32>(&state.highest_digest).is_err()
77        {
78            return Err(CatalogUpdateError::Invalid(
79                "cache version or high-water mark",
80            ));
81        }
82        Ok(Some(state))
83    }
84
85    fn verify_cached(
86        &self,
87        envelope: &SignedCatalog,
88    ) -> Result<VerifiedCatalog, CatalogUpdateError> {
89        let bytes = serde_json::to_vec(envelope)
90            .map_err(|_| CatalogUpdateError::Invalid("cache envelope"))?;
91        verify(&bytes, &self.key.ok_or(CatalogUpdateError::NotConfigured)?)
92    }
93
94    fn selected(
95        &self,
96        snapshot: VerifiedCatalog,
97        source: &'static str,
98        warnings: Vec<String>,
99    ) -> LoadedCatalog {
100        let status = CatalogStatus {
101            source,
102            revision: Some(snapshot.revision),
103            digest: snapshot.digest,
104            generated_at: snapshot.catalog.generated_at.clone(),
105            published_at: Some(snapshot.published_at),
106            model_count: snapshot.catalog.models.len(),
107            updates_configured: self.key.is_some(),
108            warnings,
109        };
110        LoadedCatalog {
111            catalog: snapshot.catalog,
112            raw: snapshot.raw,
113            status,
114        }
115    }
116
117    pub fn load(&self) -> Result<LoadedCatalog, CatalogUpdateError> {
118        let mut warnings = Vec::new();
119        match self.read_state() {
120            Ok(Some(state)) => {
121                match self.verify_cached(&state.current) {
122                    Ok(snapshot) => return Ok(self.selected(snapshot, "updated", warnings)),
123                    Err(_) => {
124                        warnings.push("Active catalog failed verification; using fallback.".into())
125                    }
126                }
127                if let Some(previous) = state.previous {
128                    match self.verify_cached(&previous) {
129                        Ok(snapshot) => return Ok(self.selected(snapshot, "previous", warnings)),
130                        Err(_) => warnings.push("Previous catalog failed verification.".into()),
131                    }
132                }
133            }
134            Ok(None) => (),
135            Err(_) => warnings
136                .push("Catalog cache is unreadable or invalid; using bundled catalog.".into()),
137        }
138        let catalog = Catalog::parse(rigspark_core::MODELS_JSON)
139            .map_err(|_| CatalogUpdateError::Invalid("bundled catalog"))?;
140        let status = CatalogStatus {
141            source: "bundled",
142            revision: None,
143            digest: format!(
144                "{:x}",
145                Sha256::digest(rigspark_core::MODELS_JSON.as_bytes())
146            ),
147            generated_at: catalog.generated_at.clone(),
148            published_at: None,
149            model_count: catalog.models.len(),
150            updates_configured: self.key.is_some(),
151            warnings,
152        };
153        Ok(LoadedCatalog {
154            catalog,
155            raw: rigspark_core::MODELS_JSON.into(),
156            status,
157        })
158    }
159
160    pub fn install(&self, bytes: &[u8]) -> Result<CatalogStatus, CatalogUpdateError> {
161        let snapshot = verify(bytes, &self.key.ok_or(CatalogUpdateError::NotConfigured)?)?;
162        std::fs::create_dir_all(&self.home)?;
163        let directory = Directory::open(&self.home)?;
164        directory.ensure_dir(Path::new("catalog"))?;
165        let cache = directory.subdir(Path::new("catalog"))?;
166        let mut options = cap_std::fs::OpenOptions::new();
167        options
168            .read(true)
169            .write(true)
170            .create(true)
171            .follow(FollowSymlinks::No);
172        #[cfg(unix)]
173        {
174            use cap_std::fs::OpenOptionsExt;
175            options
176                .mode(0o600)
177                .custom_flags(rustix::fs::OFlags::NONBLOCK.bits() as i32);
178        }
179        let lock = cache.open_with("update.lock", &options)?.into_std();
180        if !lock.metadata()?.is_file() {
181            return Err(CatalogUpdateError::Invalid("update lock"));
182        }
183        lock.try_lock().map_err(|_| CatalogUpdateError::Busy)?;
184        let state = self.read_state()?;
185        if let Some(state) = &state
186            && (snapshot.revision < state.highest_revision
187                || (snapshot.revision == state.highest_revision
188                    && snapshot.digest != state.highest_digest))
189        {
190            return Err(CatalogUpdateError::Rollback);
191        }
192        let previous = state.and_then(|state| {
193            if self
194                .verify_cached(&state.current)
195                .is_ok_and(|current| current.revision < snapshot.revision)
196            {
197                Some(state.current)
198            } else {
199                state
200                    .previous
201                    .filter(|previous| self.verify_cached(previous).is_ok())
202            }
203        });
204        let current =
205            serde_json::from_slice(bytes).map_err(|_| CatalogUpdateError::Invalid("envelope"))?;
206        let state = Snapshots {
207            version: 1,
208            highest_revision: snapshot.revision,
209            highest_digest: snapshot.digest.clone(),
210            current,
211            previous,
212        };
213        let encoded = serde_json::to_vec(&state)
214            .map_err(|_| CatalogUpdateError::Invalid("cache encoding"))?;
215        if encoded.len() as u64 > MAX_STATE_BYTES {
216            return Err(CatalogUpdateError::TooLarge);
217        }
218        directory.write(Path::new(STATE), &encoded, false, false)?;
219        Ok(self.selected(snapshot, "updated", Vec::new()).status)
220    }
221}