1use std::collections::{BTreeMap, BTreeSet};
2
3use serde::{Deserialize, Serialize};
4use subc_config::{Digest, Generation, RecordedValue};
5
6pub const RECENT_HISTORY_LIMIT: usize = 20;
8pub type Snapshot = BTreeMap<String, RecordedValue>;
9
10#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
11#[serde(rename_all = "snake_case")]
12pub enum IntegrityMode {
13 Sealed,
14 DigestOnly,
15}
16
17#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
18pub struct Tuple {
19 pub module: String,
20 pub project: Option<String>,
21}
22
23#[derive(Clone, Debug, Default, Serialize, Deserialize)]
24pub struct Versions {
25 pub active: Option<u64>,
26 pub recovery: Option<u64>,
27 pub pending: Option<u64>,
28}
29
30#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
31#[serde(rename_all = "snake_case")]
32pub enum CommitKind {
33 Stamp,
34 Unstamp,
35 Approved,
36 Rollback,
37 Development,
38}
39
40#[derive(Clone, Debug, Serialize, Deserialize)]
41pub struct DeliverySnapshot {
42 pub daemon: Option<subc_protocol::config::ConfigLayerSnapshot>,
43 pub modules: BTreeMap<String, subc_protocol::config::ConfigView>,
44 pub declarations: BTreeMap<String, subc_protocol::config::ConfigDeclareRequest>,
45}
46
47#[derive(Clone, Debug, Serialize, Deserialize)]
48pub struct HistoryEntry {
49 pub generation: Generation,
50 pub kind: CommitKind,
51 pub approval_id: String,
52 pub outcome: String,
53 pub tuples: BTreeSet<Tuple>,
54 pub configuration: Snapshot,
56 #[serde(default, skip_serializing_if = "Option::is_none")]
59 pub delivery: Option<DeliverySnapshot>,
60}
61
62#[derive(Clone, Debug, Serialize, Deserialize)]
63pub struct PrunedGeneration {
64 pub generation: u64,
65 pub approval_channel: subc_config::ApprovalChannel,
66 pub plan_digest: Digest,
67 pub approval_id: String,
68 pub outcome: String,
69 pub pruned_at_ms: u64,
70}
71
72#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
73pub struct Proposal {
74 pub base_revision: u64,
75 pub snapshot_digest: Digest,
76 pub diff: BTreeMap<String, Option<RecordedValue>>,
77}
78
79#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
81pub struct ProgramRefusal {
82 pub module: String,
83 pub approved_base: Digest,
84 pub refused_identity: Digest,
85}
86
87pub const PROGRAM_REFUSAL_LIMIT: usize = 256;
88
89pub const DAEMON_MODULE: &str = "subc";
92
93#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
96pub struct RestartIntent {
97 pub generation: u64,
98 pub attempted: bool,
101}
102
103#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
106pub struct DaemonPointers {
107 pub active: u64,
112 pub awaiting_restart: Option<u64>,
116 pub restart: Option<RestartIntent>,
117}
118
119#[derive(Clone, Debug, Default, Serialize, Deserialize)]
122pub struct StoreBody {
123 #[serde(default, skip_serializing_if = "Vec::is_empty")]
124 pub program_refusals: Vec<ProgramRefusal>,
125 pub stamped: bool,
126 pub base_revision: u64,
127 pub last_generation: u64,
128 pub approved: Snapshot,
129 pub generations: BTreeMap<u64, HistoryEntry>,
130 pub versions: Vec<(Tuple, Versions)>,
131 pub pruned: BTreeMap<u64, PrunedGeneration>,
132 pub proposal: Option<Proposal>,
133 pub observed: Option<Snapshot>,
135 pub daemon: DaemonPointers,
136}
137
138fn requires_daemon_restart(base: Option<&HistoryEntry>, entry: &HistoryEntry) -> bool {
142 if entry
143 .generation
144 .changeset
145 .fields
146 .iter()
147 .any(|field| field.apply == subc_config::ApplyKind::DaemonRestart)
148 {
149 return true;
150 }
151 if entry
152 .delivery
153 .as_ref()
154 .is_none_or(|delivery| delivery.daemon.is_none())
155 {
156 return false;
158 }
159 let (Some(base), Some(next)) = (base.and_then(daemon_config), daemon_config(entry)) else {
160 return true;
162 };
163 base.port != next.port
164 || base.storage != next.storage
165 || base.admission_facts_carrier_module_id != next.admission_facts_carrier_module_id
166 || base.admission_facts_targets != next.admission_facts_targets
167 || base.scope_authority_owners != next.scope_authority_owners
168 || base.privileged_operator_prompt != next.privileged_operator_prompt
169}
170
171fn daemon_config(entry: &HistoryEntry) -> Option<crate::daemon_config::DaemonConfig> {
172 let layer = entry.delivery.as_ref()?.daemon.as_ref()?;
173 let doc = std::str::from_utf8(layer.bytes.as_deref()?).ok()?;
174 let path = std::path::Path::new(layer.path.as_deref()?);
175 crate::daemon_config::parse_with_activity(doc, path)
176 .ok()
177 .map(|(config, _)| config)
178}
179
180pub(crate) fn generation_failed(entry: &HistoryEntry) -> bool {
182 entry.outcome == "failed"
183 || !entry.generation.never_redeliver.is_empty()
184 || entry
185 .generation
186 .module_states
187 .values()
188 .any(|state| *state == subc_config::GenerationState::Failed)
189}
190
191fn bootable(entry: &HistoryEntry) -> bool {
192 !matches!(entry.kind, CommitKind::Development | CommitKind::Unstamp)
193 && !entry.generation.development
194 && entry
195 .delivery
196 .as_ref()
197 .is_some_and(|delivery| delivery.daemon.is_some())
198 && !generation_failed(entry)
199}
200
201impl StoreBody {
202 pub(super) fn awaits_restart(&self, entry: &HistoryEntry) -> bool {
205 let base = self
206 .active_daemon_generation()
207 .and_then(|id| self.generations.get(&id));
208 self.daemon.awaiting_restart.is_none() && requires_daemon_restart(base, entry)
209 }
210
211 pub(super) fn first_awaiting_restart_after(&self, active: u64) -> Option<u64> {
214 let base = self.generations.get(&active);
215 self.generations
216 .range(active.saturating_add(1)..)
217 .find(|(_, entry)| {
218 !matches!(entry.kind, CommitKind::Development | CommitKind::Unstamp)
219 && !entry.generation.development
220 && requires_daemon_restart(base, entry)
221 })
222 .map(|(&id, _)| id)
223 }
224
225 pub(crate) fn active_daemon_generation(&self) -> Option<u64> {
229 let limit = self.daemon.awaiting_restart.unwrap_or(u64::MAX);
230 self.generations
231 .range(..limit)
232 .rev()
233 .find(|(_, entry)| bootable(entry))
234 .map(|(&id, _)| id)
235 }
236
237 pub(crate) fn restart_candidate(&self) -> Option<u64> {
240 let candidate = self
241 .generations
242 .iter()
243 .rev()
244 .find(|(_, entry)| bootable(entry))
245 .map(|(&id, _)| id)?;
246 (Some(candidate) > self.active_daemon_generation()).then_some(candidate)
247 }
248
249 pub(crate) fn bootable_generation(&self, id: u64) -> bool {
250 self.generations.get(&id).is_some_and(bootable)
251 }
252
253 pub(super) fn protected_generations(&self) -> BTreeSet<u64> {
256 let mut keep = BTreeSet::new();
257 let mut placed_modules = BTreeSet::new();
261 for (&id, entry) in self
262 .generations
263 .iter()
264 .rev()
265 .take_while(|(_, entry)| entry.kind == CommitKind::Development)
266 {
267 for module in entry.generation.changeset.launch_manifests.keys() {
268 if placed_modules.insert(module) {
269 keep.insert(id);
270 }
271 }
272 }
273 for (_, versions) in &self.versions {
274 keep.extend(
275 [versions.active, versions.recovery, versions.pending]
276 .into_iter()
277 .flatten(),
278 );
279 }
280 keep.extend(
284 [
285 self.daemon.restart.map(|intent| intent.generation),
286 self.active_daemon_generation(),
287 self.daemon.awaiting_restart,
288 ]
289 .into_iter()
290 .flatten()
291 .filter(|id| self.generations.contains_key(id)),
292 );
293 let mut daemon_versions = Vec::new();
294 for (&id, entry) in self.generations.iter().rev() {
295 if daemon_versions.len() == 2 {
296 break;
297 }
298 if entry.kind == CommitKind::Development || entry.generation.development {
299 continue;
300 }
301 let Some(daemon) = entry
302 .delivery
303 .as_ref()
304 .and_then(|delivery| delivery.daemon.as_ref())
305 else {
306 continue;
307 };
308 let Some(input) = entry.generation.input_vector.inputs.get("subc.jsonc") else {
309 keep.insert(id);
312 continue;
313 };
314 let version = (input, &daemon.digest);
315 if !daemon_versions.contains(&version) {
316 daemon_versions.push(version);
317 keep.insert(id);
318 }
319 }
320 keep
321 }
322
323 pub(super) fn prune(&mut self, now_ms: u64) {
326 let protected = self.protected_generations();
327 let mut keep = protected.clone();
328 let tuples: BTreeSet<_> = self
329 .generations
330 .values()
331 .flat_map(|e| e.tuples.iter().cloned())
332 .collect();
333 for tuple in tuples.into_iter().map(Some).chain(std::iter::once(None)) {
334 let mut recent = 0;
335 for (&id, entry) in self.generations.iter().rev() {
336 let belongs = match &tuple {
337 Some(tuple) => entry.tuples.contains(tuple),
338 None => entry.tuples.is_empty(),
339 };
340 if !belongs || protected.contains(&id) {
341 continue;
342 }
343 if recent < RECENT_HISTORY_LIMIT {
344 keep.insert(id);
345 }
346 recent += 1;
347 }
348 }
349 let removed: Vec<_> = self
350 .generations
351 .keys()
352 .copied()
353 .filter(|id| !keep.contains(id))
354 .collect();
355 for id in removed {
356 self.prune_generation(id, now_ms);
357 }
358 }
359
360 pub(super) fn prune_oldest(&mut self, now_ms: u64) -> bool {
361 let protected = self.protected_generations();
362 let Some(id) = self
363 .generations
364 .keys()
365 .copied()
366 .find(|id| !protected.contains(id))
367 else {
368 return false;
369 };
370 self.prune_generation(id, now_ms);
371 true
372 }
373
374 fn prune_generation(&mut self, id: u64, now_ms: u64) {
375 if let Some(entry) = self.generations.remove(&id) {
376 self.pruned.insert(
377 id,
378 PrunedGeneration {
379 generation: id,
380 approval_channel: entry.generation.approval_channel,
381 plan_digest: entry.generation.plan_digest,
382 approval_id: entry.approval_id,
383 outcome: entry.outcome,
384 pruned_at_ms: now_ms,
385 },
386 );
387 }
388 }
389
390 pub(super) fn rebase_proposal(&mut self) -> Result<bool, super::StoreError> {
391 let old_diff = self
392 .proposal
393 .as_ref()
394 .map(|p| &p.diff)
395 .cloned()
396 .unwrap_or_default();
397 let Some(snapshot) = &self.observed else {
398 self.proposal = None;
399 return Ok(!old_diff.is_empty());
400 };
401 let keys: BTreeSet<_> = self.approved.keys().chain(snapshot.keys()).collect();
402 let diff: BTreeMap<_, _> = keys
403 .into_iter()
404 .filter(|key| self.approved.get(*key) != snapshot.get(*key))
405 .map(|key| (key.clone(), snapshot.get(key).cloned()))
406 .collect();
407 let changed = old_diff != diff;
408 self.proposal = if diff.is_empty() {
409 None
410 } else {
411 Some(Proposal {
412 base_revision: self.base_revision,
413 snapshot_digest: subc_config::digest(
414 subc_config::PURPOSE_SNAPSHOT,
415 &serde_json::to_value(snapshot).map_err(super::StoreError::serialization)?,
416 )
417 .map_err(super::StoreError::serialization)?,
418 diff,
419 })
420 };
421 Ok(changed)
422 }
423}