rigspark_runtime/catalog_update/
store.rs1use 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}