use std::fs;
use std::path::{Path, PathBuf};
use std::sync::OnceLock;
use anyhow::{anyhow, bail, Context, Result};
use serde::Deserialize;
use sha2::{Digest, Sha256};
#[cfg(feature = "pack")]
use crate::pack::Pack;
const DEFAULT_BASE: &str = "https://treebank.dev/packs";
const MANIFEST_TTL: std::time::Duration = std::time::Duration::from_secs(3600);
#[derive(Debug, Deserialize)]
struct Manifest {
packs: std::collections::BTreeMap<String, Entry>,
}
#[derive(Debug, Deserialize)]
struct Entry {
sha256: String,
key: String,
}
fn base_url() -> String {
std::env::var("TREEBANK_PACKS_URL")
.unwrap_or_else(|_| DEFAULT_BASE.to_string())
.trim_end_matches('/')
.to_string()
}
pub fn cache_dir() -> PathBuf {
if let Ok(dir) = std::env::var("TREEBANK_CACHE") {
return PathBuf::from(dir);
}
if let Ok(dir) = std::env::var("XDG_CACHE_HOME") {
return PathBuf::from(dir).join("treebank");
}
if let Ok(home) = std::env::var("HOME") {
return PathBuf::from(home).join(".cache").join("treebank");
}
std::env::temp_dir().join("treebank")
}
fn packs_dir() -> PathBuf {
cache_dir().join("packs")
}
const BODY_LIMIT: u64 = 64 * 1024 * 1024;
fn agent() -> &'static ureq::Agent {
static AGENT: OnceLock<ureq::Agent> = OnceLock::new();
AGENT.get_or_init(|| {
let _ = rustls_graviola::default_provider().install_default();
ureq::Agent::config_builder()
.tls_config(
ureq::tls::TlsConfig::builder()
.root_certs(ureq::tls::RootCerts::PlatformVerifier)
.build(),
)
.build()
.into()
})
}
fn get(url: &str) -> Result<Vec<u8>> {
let mut response = agent()
.get(url)
.call()
.with_context(|| format!("fetching {url}"))?;
response
.body_mut()
.with_config()
.limit(BODY_LIMIT)
.read_to_vec()
.with_context(|| format!("reading {url}"))
}
fn sha256_hex(bytes: &[u8]) -> String {
let mut hasher = Sha256::new();
hasher.update(bytes);
hasher.finalize().iter().map(|b| format!("{b:02x}")).collect()
}
fn cache_atomically(path: &Path, bytes: &[u8]) -> Result<()> {
let dir = path.parent().ok_or_else(|| anyhow!("no parent for {}", path.display()))?;
fs::create_dir_all(dir).with_context(|| format!("creating {}", dir.display()))?;
let tmp = dir.join(format!(".{}.{}", std::process::id(), rand_suffix()));
fs::write(&tmp, bytes).with_context(|| format!("writing {}", tmp.display()))?;
fs::rename(&tmp, path).with_context(|| format!("installing {}", path.display()))?;
Ok(())
}
fn rand_suffix() -> String {
use std::time::{SystemTime, UNIX_EPOCH};
let nanos = SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.subsec_nanos()).unwrap_or(0);
format!("{nanos:08x}")
}
fn manifest() -> Result<Manifest> {
let path = cache_dir().join("packs-index.json");
let fresh = fs::metadata(&path)
.and_then(|m| m.modified())
.map(|t| t.elapsed().map(|age| age < MANIFEST_TTL).unwrap_or(false))
.unwrap_or(false);
if fresh {
if let Ok(bytes) = fs::read(&path) {
if let Ok(parsed) = serde_json::from_slice(&bytes) {
return Ok(parsed);
}
}
}
let url = format!("{}/index.json", base_url());
match get(&url) {
Ok(bytes) => {
let parsed = serde_json::from_slice(&bytes)
.with_context(|| format!("parsing the manifest from {url}"))?;
let _ = cache_atomically(&path, &bytes);
Ok(parsed)
}
Err(network) => {
let bytes = fs::read(&path).map_err(|_| network)?;
serde_json::from_slice(&bytes).context("parsing the cached manifest")
}
}
}
#[cfg(feature = "pack")]
pub fn fetch(grammar: &str) -> Result<Pack> {
let (key, sha256) = key_for(grammar)?;
load_verified(&key, &sha256)
}
#[cfg(feature = "pack")]
pub fn fetch_pinned(grammar: &str, hash: &str) -> Result<Pack> {
load_verified(&pinned_key(grammar, hash)?, hash)
}
pub fn cached_path(key: &str) -> PathBuf {
packs_dir().join(key)
}
fn bytes_verified(key: &str, expected: &str) -> Result<Vec<u8>> {
let path = cached_path(key);
if let Ok(bytes) = fs::read(&path) {
if starts_with_hash(&sha256_hex(&bytes), expected) {
return Ok(bytes);
}
let _ = fs::remove_file(&path);
}
let url = format!("{}/{key}", base_url());
let bytes = get(&url)?;
let actual = sha256_hex(&bytes);
if !starts_with_hash(&actual, expected) {
bail!(
"{url} does not have the expected contents\n expected sha256 {expected}\n \
got sha256 {actual}"
);
}
cache_atomically(&path, &bytes)?;
Ok(bytes)
}
fn key_for(grammar: &str) -> Result<(String, String)> {
let manifest = manifest()?;
let entry = manifest.packs.get(grammar).ok_or_else(|| {
let known: Vec<_> = manifest.packs.keys().cloned().collect();
anyhow!("no grammar named {grammar}; the manifest has {}", known.join(", "))
})?;
Ok((entry.key.clone(), entry.sha256.clone()))
}
fn pinned_key(grammar: &str, hash: &str) -> Result<String> {
if !hash.chars().all(|c| c.is_ascii_hexdigit()) || hash.len() < 8 {
bail!("{hash} is not a pack hash");
}
Ok(format!("treebank-{grammar}-{}.wasm", &hash[..12.min(hash.len())]))
}
#[cfg(feature = "fetch-bytes")]
pub fn fetch_bytes(grammar: &str) -> Result<Vec<u8>> {
let (key, sha256) = key_for(grammar)?;
bytes_verified(&key, &sha256)
}
#[cfg(feature = "fetch-bytes")]
pub fn fetch_pinned_bytes(grammar: &str, hash: &str) -> Result<Vec<u8>> {
bytes_verified(&pinned_key(grammar, hash)?, hash)
}
#[cfg(feature = "pack")]
fn load_verified(key: &str, expected: &str) -> Result<Pack> {
let bytes = bytes_verified(key, expected)?;
Pack::from_bytes(&bytes).with_context(|| format!("loading {key}"))
}
fn starts_with_hash(actual: &str, expected: &str) -> bool {
let expected = expected.to_ascii_lowercase();
!expected.is_empty() && actual.starts_with(&expected)
}
#[cfg(feature = "pack")]
impl Pack {
pub fn fetch(grammar: &str) -> Result<Pack> {
fetch(grammar)
}
pub fn fetch_pinned(grammar: &str, hash: &str) -> Result<Pack> {
fetch_pinned(grammar, hash)
}
}