use std::collections::HashMap;
use std::io;
use std::path::{Path, PathBuf};
use chrono::{DateTime, Utc};
use rusty_agent_runtime::capsule::{CapsuleId, CapsuleManifest};
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub(crate) struct CapsuleRecord {
pub capsule_id: CapsuleId,
pub manifest: CapsuleManifest,
pub registered_at: DateTime<Utc>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum CapsuleWrite {
Created,
Converged,
Conflict,
}
pub(crate) fn manifests_dir(root: &Path) -> PathBuf {
root.join("capsules").join("manifests")
}
pub(crate) async fn persist_capsule(
root: &Path,
scoped_id: &str,
record: &CapsuleRecord,
) -> io::Result<()> {
let dir = manifests_dir(root);
tokio::fs::create_dir_all(&dir).await?;
let bytes = serde_json::to_vec_pretty(record)
.map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
let path = dir.join(format!("{scoped_id}.json"));
if let Some(parent) = path.parent() {
tokio::fs::create_dir_all(parent).await?;
}
let tmp = dir.join(format!("{scoped_id}.tmp"));
tokio::fs::write(&tmp, bytes).await?;
tokio::fs::rename(&tmp, path).await
}
fn collect_json_files(root: &Path, out: &mut Vec<PathBuf>) {
let Ok(entries) = std::fs::read_dir(root) else {
return;
};
for entry in entries.flatten() {
let path = entry.path();
if path.is_dir() {
collect_json_files(&path, out);
} else if path.extension().and_then(|e| e.to_str()) == Some("json") {
out.push(path);
}
}
}
fn path_scoped_id(dir: &Path, path: &Path) -> Option<String> {
path.strip_prefix(dir)
.ok()
.map(|relative| relative.with_extension(""))
.map(|relative| {
relative
.components()
.map(|component| component.as_os_str().to_string_lossy().into_owned())
.collect::<Vec<_>>()
.join("/")
})
}
pub(crate) fn load_capsules(root: &Path) -> HashMap<String, CapsuleRecord> {
let dir = manifests_dir(root);
let mut out = HashMap::new();
let mut files = Vec::new();
collect_json_files(&dir, &mut files);
for path in files {
let scoped_id = path_scoped_id(&dir, &path);
let parsed = std::fs::read_to_string(&path)
.ok()
.and_then(|raw| serde_json::from_str::<CapsuleRecord>(&raw).ok());
match (scoped_id, parsed) {
(Some(id), Some(record)) => {
out.insert(id, record);
}
_ => {
tracing::warn!(path = %path.display(), "skipping unreadable capsule file")
}
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
use rusty_agent_runtime::capsule::{
CapabilityGrant, CapsuleIdentity, CapsuleInterface, ResourceBudget, WORLD_V1,
};
use rusty_agent_runtime::record::{sha256_hex, Effect};
use std::collections::BTreeSet;
fn ts(millis: i64) -> DateTime<Utc> {
DateTime::<Utc>::from_timestamp_millis(millis).unwrap()
}
fn record(name: &str) -> CapsuleRecord {
let manifest = CapsuleManifest {
identity: CapsuleIdentity {
name: name.into(),
description: None,
},
version: "0.1.0".into(),
build_digest: sha256_hex(name.as_bytes()),
interface: CapsuleInterface {
world: WORLD_V1.into(),
input_schema: None,
output_schema: None,
},
effects: BTreeSet::from([Effect::Pure]),
capabilities: BTreeSet::from([CapabilityGrant::Clock]),
budget: ResourceBudget::default(),
};
CapsuleRecord {
capsule_id: manifest.capsule_id().unwrap(),
manifest,
registered_at: ts(1_000),
}
}
#[tokio::test]
async fn layout_round_trips_and_skips_corrupt_files() {
let root =
std::env::temp_dir().join(format!("rusty-capsules-test-{}", uuid::Uuid::new_v4()));
let a = record("probe-a");
let b = record("probe-b");
persist_capsule(&root, a.capsule_id.as_str(), &a)
.await
.unwrap();
let scoped_b = crate::auth::scope_id("acme", b.capsule_id.as_str());
persist_capsule(&root, &scoped_b, &b).await.unwrap();
std::fs::create_dir_all(manifests_dir(&root)).unwrap();
std::fs::write(manifests_dir(&root).join("broken.json"), b"{nope").unwrap();
let loaded = load_capsules(&root);
assert_eq!(loaded.len(), 2, "corrupt files are skipped, not fatal");
assert!(
loaded.contains_key(a.capsule_id.as_str()),
"default tenant: bare key"
);
assert!(loaded.contains_key(&scoped_b));
let _ = std::fs::remove_dir_all(root);
}
}