use std::io::{Read, Write};
use std::path::{Path, PathBuf};
use std::time::{Duration, Instant};
use anyhow::{anyhow, Context, Result};
use serde::Deserialize;
use crate::fmt::human_size;
use crate::fsutil::sha256_of_file;
#[cfg(any(target_os = "linux", target_os = "windows"))]
use crate::hostgpu::HostGpu;
const REPO_API: &str = "https://api.github.com/repos/ggml-org/llama.cpp";
pub fn default_release() -> &'static str {
include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/LLAMA_CPP_RELEASE")).trim()
}
fn build_tag(pin: &str) -> &str {
pin.strip_prefix('v')
.and_then(|_| pin.split('-').nth(1))
.unwrap_or(pin)
}
#[derive(Debug, Deserialize)]
struct Release {
tag_name: String,
assets: Vec<Asset>,
}
#[derive(Debug, Clone, Deserialize)]
struct Asset {
name: String,
browser_download_url: String,
size: u64,
digest: Option<String>,
}
pub(crate) fn http_client() -> Result<reqwest::blocking::Client> {
reqwest::blocking::Client::builder()
.timeout(Duration::from_secs(60 * 30))
.build()
.context("build http client")
}
fn http_get(
client: &reqwest::blocking::Client,
url: &str,
what: &str,
) -> Result<reqwest::blocking::Response> {
let resp = client
.get(url)
.header("user-agent", "llmman")
.send()
.with_context(|| format!("query {url}"))?;
if !resp.status().is_success() {
anyhow::bail!("{what} {url} returned {}", resp.status());
}
Ok(resp)
}
fn fetch_release(client: &reqwest::blocking::Client, version: Option<&str>) -> Result<Release> {
let url = match version {
Some(v) => format!("{REPO_API}/releases/tags/{v}"),
None => format!("{REPO_API}/releases/latest"),
};
http_get(client, &url, "GitHub API")?
.json::<Release>()
.with_context(|| format!("parse release metadata from {url}"))
}
const NIGHTLY_POINTER: &str = "nightly-tag.txt";
fn pointer_asset(release: &Release) -> Option<&Asset> {
if release.assets.len() != 1 {
return None;
}
release.assets.iter().find(|a| a.name == NIGHTLY_POINTER)
}
fn parse_pointer_tag(content: &str) -> Option<&str> {
let trimmed = content.trim();
(!trimmed.is_empty()).then_some(trimmed)
}
fn resolve_release(client: &reqwest::blocking::Client, version: Option<&str>) -> Result<Release> {
resolve_release_with(
|v| fetch_release(client, v),
|url| fetch_text(client, url),
version,
)
}
fn resolve_release_with(
fetch_release_fn: impl Fn(Option<&str>) -> Result<Release>,
fetch_text_fn: impl Fn(&str) -> Result<String>,
version: Option<&str>,
) -> Result<Release> {
let release = fetch_release_fn(version)?;
let Some(pointer) = pointer_asset(&release) else {
return Ok(release);
};
let pointer_tag = &release.tag_name;
let content = fetch_text_fn(&pointer.browser_download_url).with_context(|| {
format!("download {NIGHTLY_POINTER} from pointer release {pointer_tag}")
})?;
let tag = parse_pointer_tag(&content)
.ok_or_else(|| anyhow!("pointer release {pointer_tag}'s {NIGHTLY_POINTER} is empty"))?;
let dereferenced = fetch_release_fn(Some(tag)).with_context(|| {
format!("pointer release {pointer_tag} names tag {tag}, but fetching that release failed")
})?;
if pointer_asset(&dereferenced).is_some() {
anyhow::bail!(
"pointer release {pointer_tag} names tag {tag}, which is itself \
only a {NIGHTLY_POINTER} pointer release (refusing to follow a \
pointer chain)"
);
}
Ok(dereferenced)
}
fn fetch_text(client: &reqwest::blocking::Client, url: &str) -> Result<String> {
http_get(client, url, "download")?
.text()
.with_context(|| format!("read body of {url}"))
}
fn pattern_version(name: &str, pattern: &str) -> Option<u32> {
let Some((before, after)) = pattern.split_once('*') else {
return name.contains(pattern).then_some(0);
};
name.match_indices(before).find_map(|(at, _)| {
let rest = &name[at + before.len()..];
let digits = rest.len() - rest.trim_start_matches(|c: char| c.is_ascii_digit()).len();
rest[digits..]
.starts_with(after)
.then(|| rest[..digits].parse().ok())
.flatten()
})
}
struct AssetQuery {
must_contain: String,
companion_must_contain: Option<String>,
label: String,
}
fn find_primary_asset<'a>(release: &'a Release, query: &AssetQuery) -> Option<&'a Asset> {
release
.assets
.iter()
.filter(|a| {
query
.companion_must_contain
.as_ref()
.is_none_or(|companion| pattern_version(&a.name, companion).is_none())
})
.filter_map(|a| Some((pattern_version(&a.name, &query.must_contain)?, a)))
.reduce(|best, next| if next.0 > best.0 { next } else { best })
.map(|(_, a)| a)
}
fn find_companion_asset<'a>(
release: &'a Release,
query: &AssetQuery,
primary: &Asset,
) -> Option<&'a Asset> {
let companion = query.companion_must_contain.as_deref()?;
let version = pattern_version(&primary.name, &query.must_contain)?;
let is_companion = |a: &&Asset| pattern_version(&a.name, companion) == Some(version);
release.assets.iter().find(is_companion)
}
#[cfg(any(target_os = "windows", test))]
fn windows_vulkan_query(arch: &str) -> AssetQuery {
AssetQuery {
must_contain: format!("-bin-win-vulkan-{arch}.zip"),
companion_must_contain: None,
label: "vulkan".into(),
}
}
#[cfg(any(target_os = "windows", test))]
fn windows_cuda_query(major: u32, arch: &str) -> AssetQuery {
AssetQuery {
must_contain: format!("-bin-win-cuda-{major}.*-{arch}.zip"),
companion_must_contain: Some(format!("cudart-llama-bin-win-cuda-{major}.*-{arch}.zip")),
label: format!("cuda-{major}"),
}
}
fn host_arch_token() -> &'static str {
match std::env::consts::ARCH {
"x86_64" => "x64",
"aarch64" => "arm64",
"s390x" => "s390x",
other => other,
}
}
fn asset_query() -> AssetQuery {
let arch = host_arch_token();
#[cfg(target_os = "macos")]
{
if arch == "arm64" {
AssetQuery {
must_contain: "-bin-macos-arm64.tar.gz".into(),
companion_must_contain: None,
label: "metal".into(),
}
} else {
AssetQuery {
must_contain: "-bin-macos-x64.tar.gz".into(),
companion_must_contain: None,
label: "cpu".into(),
}
}
}
#[cfg(target_os = "linux")]
{
match crate::hostgpu::detect() {
HostGpu::Vulkan => AssetQuery {
must_contain: format!("-bin-ubuntu-vulkan-{arch}.tar.gz"),
companion_must_contain: None,
label: "vulkan".into(),
},
HostGpu::Rocm if arch == "x64" => AssetQuery {
must_contain: "-bin-ubuntu-rocm-".into(),
companion_must_contain: None,
label: "rocm".into(),
},
HostGpu::Cuda { .. } => {
eprintln!(
"[llmman] NVIDIA GPU detected, but llama.cpp does not publish a \
prebuilt Linux CUDA binary — falling back to the CPU build. Use \
`llmman serve --runtime docker` (or `--runtime podman`) for GPU \
acceleration on Linux, or build llama.cpp yourself with \
GGML_CUDA=ON and put llama-server on PATH."
);
AssetQuery {
must_contain: format!("-bin-ubuntu-{arch}.tar.gz"),
companion_must_contain: None,
label: "cpu".into(),
}
}
_ => AssetQuery {
must_contain: format!("-bin-ubuntu-{arch}.tar.gz"),
companion_must_contain: None,
label: "cpu".into(),
},
}
}
#[cfg(target_os = "windows")]
{
match crate::hostgpu::detect() {
HostGpu::Cuda { major } => {
let cuda = if arch == "arm64" || major >= 13 {
13
} else {
12
};
windows_cuda_query(cuda, arch)
}
HostGpu::Rocm if arch == "x64" => AssetQuery {
must_contain: "-bin-win-rocm-".into(),
companion_must_contain: None,
label: "rocm".into(),
},
HostGpu::Opencl if arch == "arm64" => AssetQuery {
must_contain: "-bin-win-opencl-adreno-arm64.zip".into(),
companion_must_contain: None,
label: "opencl".into(),
},
HostGpu::Vulkan => windows_vulkan_query(arch),
_ => AssetQuery {
must_contain: format!("-bin-win-cpu-{arch}.zip"),
companion_must_contain: None,
label: "cpu".into(),
},
}
}
#[cfg(target_os = "android")]
{
AssetQuery {
must_contain: format!("-bin-android-{arch}.tar.gz"),
companion_must_contain: None,
label: "cpu".into(),
}
}
#[cfg(not(any(
target_os = "macos",
target_os = "linux",
target_os = "windows",
target_os = "android"
)))]
{
AssetQuery {
must_contain: format!("-bin-ubuntu-{arch}.tar.gz"),
companion_must_contain: None,
label: "cpu".into(),
}
}
}
fn install_root() -> Result<PathBuf> {
Ok(crate::data_root()?.join("llama.cpp"))
}
fn install_dir(tag: &str, label: &str) -> Result<PathBuf> {
Ok(install_root()?.join(tag).join(label))
}
fn tmp_dir() -> Result<PathBuf> {
if let Some(dir) = tmp_dir_from_env() {
return Ok(dir);
}
Ok(install_root()?.join("tmp"))
}
fn tmp_dir_from_env() -> Option<PathBuf> {
parse_tmp_dir(std::env::var("LLMMAN_TMPDIR").ok().as_deref())
}
fn parse_tmp_dir(value: Option<&str>) -> Option<PathBuf> {
let trimmed = value?.trim();
(!trimmed.is_empty()).then(|| PathBuf::from(trimmed))
}
pub(crate) fn tmp_path(name: &str) -> Result<PathBuf> {
let dir = tmp_dir()?;
std::fs::create_dir_all(&dir).with_context(|| format!("create {}", dir.display()))?;
Ok(dir.join(format!("{name}.tmp-{}", std::process::id())))
}
pub(crate) struct RemoveOnDrop<'a>(pub(crate) &'a Path);
impl Drop for RemoveOnDrop<'_> {
fn drop(&mut self) {
let _ = std::fs::remove_file(self.0);
}
}
pub(crate) fn find_binary(dir: &Path, name: &str) -> Option<PathBuf> {
walkdir::WalkDir::new(dir)
.into_iter()
.filter_map(|e| e.ok())
.find(|e| e.file_type().is_file() && e.file_name().to_str() == Some(name))
.map(|e| e.path().to_path_buf())
}
const PROGRESS_LOG_INTERVAL: Duration = Duration::from_secs(5);
const DOWNLOAD_MARKER_STALE_AFTER: Duration = Duration::from_secs(60);
const MARKER_HEARTBEAT: Duration = Duration::from_secs(15);
fn download_marker_path() -> Result<PathBuf> {
Ok(install_root()?.join(".downloading"))
}
pub fn download_in_progress() -> bool {
download_status().is_some()
}
pub fn download_status() -> Option<String> {
let path = download_marker_path().ok()?;
marker_status(&path, DOWNLOAD_MARKER_STALE_AFTER)
}
fn marker_status(path: &Path, stale_after: Duration) -> Option<String> {
marker_is_fresh(path, stale_after)
.then(|| std::fs::read_to_string(path).unwrap_or_default())
.map(|text| text.trim().to_string())
}
fn marker_is_fresh(path: &Path, stale_after: Duration) -> bool {
let Ok(mtime) = std::fs::metadata(path).and_then(|m| m.modified()) else {
return false;
};
std::time::SystemTime::now()
.duration_since(mtime)
.map_or(true, |age| age < stale_after)
}
pub(crate) struct DownloadMarker {
path: Option<PathBuf>,
status: std::sync::Mutex<String>,
}
impl DownloadMarker {
pub(crate) fn create() -> DownloadMarker {
match download_marker_path() {
Ok(p) => Self::create_at(p),
Err(_) => Self::at(None),
}
}
pub(crate) fn create_at(path: PathBuf) -> DownloadMarker {
if let Some(parent) = path.parent() {
let _ = std::fs::create_dir_all(parent);
}
Self::at(std::fs::write(&path, b"").ok().map(|_| path))
}
fn at(path: Option<PathBuf>) -> DownloadMarker {
DownloadMarker {
path,
status: std::sync::Mutex::new(String::new()),
}
}
pub(crate) fn touch(&self) {
if let Ok(s) = self.status.lock() {
self.write(&s);
}
}
pub(crate) fn set_status(&self, status: &str) {
if let Ok(mut s) = self.status.lock() {
*s = status.to_string();
self.write(&s);
}
}
pub(crate) fn keep_alive_during<T>(&self, work: impl FnOnce() -> T) -> T {
self.keep_alive_every(MARKER_HEARTBEAT, work)
}
fn keep_alive_every<T>(&self, interval: Duration, work: impl FnOnce() -> T) -> T {
let (done_tx, done_rx) = std::sync::mpsc::channel::<()>();
std::thread::scope(|scope| {
scope.spawn(move || loop {
match done_rx.recv_timeout(interval) {
Err(std::sync::mpsc::RecvTimeoutError::Timeout) => self.touch(),
_ => return,
}
});
let out = work();
drop(done_tx);
out
})
}
fn write(&self, text: &str) {
if let Some(path) = &self.path {
let _ = std::fs::write(path, text.as_bytes());
if let Ok(file) = std::fs::File::options().write(true).open(path) {
let _ = file.set_modified(std::time::SystemTime::now());
}
}
}
}
impl Drop for DownloadMarker {
fn drop(&mut self) {
if let Some(path) = &self.path {
let _ = std::fs::remove_file(path);
}
}
}
pub(crate) fn create_new_file(dest: &Path) -> Result<std::fs::File> {
let open = || {
std::fs::OpenOptions::new()
.write(true)
.create_new(true)
.open(dest)
};
match open() {
Ok(f) => Ok(f),
Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {
std::fs::remove_file(dest)
.with_context(|| format!("remove stale {}", dest.display()))?;
open().with_context(|| format!("create {}", dest.display()))
}
Err(e) => Err(e).with_context(|| format!("create {}", dest.display())),
}
}
pub(crate) fn download_to_file(
client: &reqwest::blocking::Client,
url: &str,
dest: &Path,
label: &str,
marker: Option<&DownloadMarker>,
) -> Result<()> {
let mut resp = client
.get(url)
.send()
.with_context(|| format!("download {url}"))?;
if !resp.status().is_success() {
anyhow::bail!("download {url} returned {}", resp.status());
}
let total = resp.content_length().unwrap_or(0);
let mut file = create_new_file(dest)?;
let mut buf = [0u8; 1 << 16];
let mut downloaded = 0u64;
let mut last_logged = Instant::now();
loop {
let n = resp.read(&mut buf).context("read download stream")?;
if n == 0 {
break;
}
file.write_all(&buf[..n]).context("write downloaded data")?;
downloaded += n as u64;
if last_logged.elapsed() >= PROGRESS_LOG_INTERVAL {
let progress = download_progress_text(label, downloaded, total);
if let Some(marker) = marker {
marker.set_status(&format!("downloading {progress}"));
}
if total > 0 {
eprintln!("[llmman] downloading {progress}");
}
last_logged = Instant::now();
}
}
eprintln!("[llmman] downloaded {label}: {}", human_size(downloaded));
Ok(())
}
fn check_download(path: &Path, asset: &Asset) -> Result<()> {
let size = std::fs::metadata(path)
.with_context(|| format!("stat {}", path.display()))?
.len();
if size != asset.size {
anyhow::bail!(
"{}: downloaded {size} bytes, release lists {}",
asset.name,
asset.size
);
}
let Some(digest) = &asset.digest else {
return Ok(());
};
let expected = digest
.strip_prefix("sha256:")
.ok_or_else(|| anyhow!("{}: unsupported digest {digest}", asset.name))?;
let actual = sha256_of_file(path)?;
if !actual.eq_ignore_ascii_case(expected) {
anyhow::bail!(
"{}: sha256 {actual} does not match published {expected}",
asset.name
);
}
Ok(())
}
fn download_progress_text(label: &str, downloaded: u64, total: u64) -> String {
if total > 0 {
format!(
"{label}: {} / {} ({}%)",
human_size(downloaded),
human_size(total),
downloaded.saturating_mul(100) / total
)
} else {
format!("{label}: {}", human_size(downloaded))
}
}
pub(crate) fn extract_tar_gz(archive_path: &Path, dest: &Path) -> Result<()> {
std::fs::create_dir_all(dest).with_context(|| format!("create {}", dest.display()))?;
let file = std::fs::File::open(archive_path)
.with_context(|| format!("open {}", archive_path.display()))?;
let gz = flate2::read::GzDecoder::new(file);
let mut archive = tar::Archive::new(gz);
archive
.unpack(dest)
.with_context(|| format!("extract {} into {}", archive_path.display(), dest.display()))?;
clear_quarantine(dest);
Ok(())
}
#[cfg(target_os = "macos")]
fn clear_quarantine(dir: &Path) {
use std::os::unix::ffi::OsStrExt;
for entry in walkdir::WalkDir::new(dir).into_iter().flatten() {
if let Ok(path) = std::ffi::CString::new(entry.path().as_os_str().as_bytes()) {
unsafe {
libc::removexattr(
path.as_ptr(),
c"com.apple.quarantine".as_ptr(),
libc::XATTR_NOFOLLOW,
);
}
}
}
}
#[cfg(not(target_os = "macos"))]
fn clear_quarantine(_dir: &Path) {}
fn extract_zip(archive_path: &Path, dest: &Path) -> Result<()> {
std::fs::create_dir_all(dest).with_context(|| format!("create {}", dest.display()))?;
let file = std::fs::File::open(archive_path)
.with_context(|| format!("open {}", archive_path.display()))?;
let mut archive = zip::ZipArchive::new(file)
.with_context(|| format!("read zip {}", archive_path.display()))?;
archive
.extract(dest)
.with_context(|| format!("extract {} into {}", archive_path.display(), dest.display()))
}
fn extract(archive_path: &Path, archive_name: &str, dest: &Path) -> Result<()> {
if archive_name.ends_with(".zip") {
extract_zip(archive_path, dest)
} else {
extract_tar_gz(archive_path, dest)
}
}
pub struct Resolved {
pub bin: PathBuf,
pub backend_label: String,
}
pub fn ensure_llama_server(pinned_version: Option<&str>) -> Result<Resolved> {
let resolved = resolve_llama_server(pinned_version)?;
if let Some(dir) = install_root()
.ok()
.and_then(|root| install_dir_of(&root, &resolved.bin))
{
clear_quarantine(&dir);
}
Ok(resolved)
}
fn install_dir_of(root: &Path, bin: &Path) -> Option<PathBuf> {
let rel = bin.strip_prefix(root).ok()?;
Some(root.join(rel.components().take(2).collect::<PathBuf>()))
}
fn resolve_llama_server(pinned_version: Option<&str>) -> Result<Resolved> {
let pinned_version = pinned_version.map(build_tag);
let query = asset_query();
let bin_name = if cfg!(target_os = "windows") {
"llama-server.exe"
} else {
"llama-server"
};
if let Some(tag) = pinned_version {
let tag_dir = install_root()?.join(tag);
if let Some(bin) = cached_in_tag(&tag_dir, &query.label, bin_name) {
return Ok(Resolved {
bin,
backend_label: query.label,
});
}
} else {
if let Some(bin) = newest_cached(&query.label, bin_name)? {
match try_ensure_from_network(pinned_version, &query, bin_name) {
Ok(resolved) => return Ok(resolved),
Err(e) => {
eprintln!(
"[llmman] could not check for a newer llama-server release ({e:#}); \
using previously downloaded build"
);
return Ok(Resolved {
bin,
backend_label: query.label,
});
}
}
}
}
try_ensure_from_network(pinned_version, &query, bin_name)
}
fn try_ensure_from_network(
pinned_version: Option<&str>,
query: &AssetQuery,
bin_name: &str,
) -> Result<Resolved> {
let client = http_client()?;
let release = resolve_release(&client, pinned_version)?;
let tag = release.tag_name.clone();
let dest = install_dir(&tag, &query.label)?;
let cached = |dest: &Path| crate::managed::completed_binary(dest, bin_name);
let bin = crate::managed::ensure(&install_root()?, &dest, "llama.cpp", cached, |dest| {
let asset = find_primary_asset(&release, query)
.with_context(|| {
format!(
"no {} llama.cpp release asset found in {tag} (looked for a name matching {:?})",
query.label, query.must_contain
)
})?
.clone();
eprintln!(
"[llmman] downloading llama-server ({}) {tag}: {}",
query.label, asset.name
);
let marker = DownloadMarker::create();
let fetch = |asset: &Asset| -> Result<()> {
let tmp = tmp_path(&asset.name)?;
let _cleanup = RemoveOnDrop(&tmp);
download_to_file(
&client,
&asset.browser_download_url,
&tmp,
&asset.name,
Some(&marker),
)?;
check_download(&tmp, asset)?;
marker.set_status(&format!("extracting {}", asset.name));
extract(&tmp, &asset.name, dest)
};
marker.keep_alive_during(|| -> Result<()> {
fetch(&asset)?;
if let Some(companion_substr) = &query.companion_must_contain {
match find_companion_asset(&release, query, &asset) {
Some(companion) => {
eprintln!("[llmman] downloading {}", companion.name);
fetch(companion)?;
}
None => eprintln!(
"[llmman] warning: expected companion asset matching {companion_substr:?} \
not found in release {tag} — {} may be missing runtime libraries it needs",
query.label
),
}
}
Ok(())
})?;
let bin = find_binary(dest, bin_name).with_context(|| {
format!(
"llama-server binary not found after extracting {}",
asset.name
)
})?;
mark_executable(&bin)?;
Ok(bin)
})?;
Ok(Resolved {
bin,
backend_label: query.label.clone(),
})
}
#[cfg(unix)]
pub(crate) fn mark_executable(path: &Path) -> Result<()> {
use std::os::unix::fs::PermissionsExt;
let mut perm = std::fs::metadata(path)?.permissions();
perm.set_mode(perm.mode() | 0o111);
std::fs::set_permissions(path, perm).with_context(|| format!("chmod +x {}", path.display()))
}
#[cfg(not(unix))]
pub(crate) fn mark_executable(_path: &Path) -> Result<()> {
Ok(())
}
fn build_number(tag: &str) -> Option<u64> {
tag.strip_prefix('b')?.parse().ok()
}
fn cached_in_tag(tag_dir: &Path, label: &str, bin_name: &str) -> Option<PathBuf> {
if let Some(bin) = crate::managed::completed_binary(&tag_dir.join(label), bin_name) {
return Some(bin);
}
let legacy = format!("{label}.");
std::fs::read_dir(tag_dir)
.ok()?
.flatten()
.filter(|e| e.file_name().to_string_lossy().starts_with(&legacy))
.find_map(|e| crate::managed::completed_binary(&e.path(), bin_name))
}
fn newest_cached(label: &str, bin_name: &str) -> Result<Option<PathBuf>> {
let root = install_root()?;
let Ok(entries) = std::fs::read_dir(&root) else {
return Ok(None);
};
let mut best: Option<(u64, PathBuf)> = None;
for entry in entries.flatten() {
if !entry.path().is_dir() {
continue;
}
let tag = entry.file_name().to_string_lossy().into_owned();
let Some(build) = build_number(&tag) else {
continue;
};
let Some(bin) = cached_in_tag(&entry.path(), label, bin_name) else {
continue;
};
if best.as_ref().map(|(b, _)| build > *b).unwrap_or(true) {
best = Some((build, bin));
}
}
Ok(best.map(|(_, bin)| bin))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parse_tmp_dir_returns_none_when_unset_or_blank() {
assert_eq!(parse_tmp_dir(None), None);
assert_eq!(parse_tmp_dir(Some("")), None);
assert_eq!(parse_tmp_dir(Some(" ")), None);
}
#[test]
fn parse_tmp_dir_trims_and_returns_the_given_path() {
assert_eq!(
parse_tmp_dir(Some(" /custom/tmp ")),
Some(PathBuf::from("/custom/tmp"))
);
}
#[test]
#[cfg(unix)]
fn create_new_file_never_writes_through_a_planted_symlink() {
use std::os::unix::fs::symlink;
let dir = std::env::temp_dir().join(format!(
"llmman-create-new-file-test-{}",
std::process::id()
));
std::fs::create_dir_all(&dir).unwrap();
let victim = dir.join("victim");
let dest = dir.join("dest");
std::fs::write(&victim, b"do not touch").unwrap();
symlink(&victim, &dest).unwrap();
create_new_file(&dest).unwrap();
assert_eq!(std::fs::read(&victim).unwrap(), b"do not touch");
assert!(dest.is_file() && !dest.is_symlink());
std::fs::remove_dir_all(&dir).unwrap();
}
#[test]
fn release_assets_parse_size_and_digest() {
let release: Release = serde_json::from_str(
r#"{"tag_name": "b1", "assets": [
{"name": "a.zip", "browser_download_url": "", "size": 3, "digest": "sha256:ab"},
{"name": "b.zip", "browser_download_url": "", "size": 4, "digest": null}
]}"#,
)
.unwrap();
assert_eq!(release.assets[0].size, 3);
assert_eq!(release.assets[0].digest.as_deref(), Some("sha256:ab"));
assert_eq!(release.assets[1].size, 4);
assert_eq!(release.assets[1].digest, None);
}
#[test]
fn install_dir_of_trims_a_binary_to_its_tag_and_label() {
let root = Path::new("/data/llama.cpp");
let bin = root
.join("b9000")
.join("metal")
.join("llama-b9000")
.join("llama-server");
assert_eq!(
install_dir_of(root, &bin),
Some(root.join("b9000").join("metal"))
);
assert_eq!(
install_dir_of(root, Path::new("/usr/bin/llama-server")),
None
);
}
#[cfg(target_os = "macos")]
#[test]
fn clear_quarantine_drops_the_flag_from_nested_files() {
use std::os::unix::ffi::OsStrExt;
let dir = tempfile::tempdir().unwrap();
let file = dir.path().join("a").join("libggml.dylib");
std::fs::create_dir_all(file.parent().unwrap()).unwrap();
std::fs::write(&file, b"x").unwrap();
let path = std::ffi::CString::new(file.as_os_str().as_bytes()).unwrap();
let name = c"com.apple.quarantine";
let value = b"0081;0;x;";
let set = unsafe {
libc::setxattr(
path.as_ptr(),
name.as_ptr(),
value.as_ptr().cast(),
value.len(),
0,
0,
)
};
assert_eq!(set, 0);
clear_quarantine(dir.path());
let got =
unsafe { libc::getxattr(path.as_ptr(), name.as_ptr(), std::ptr::null_mut(), 0, 0, 0) };
assert_eq!(got, -1);
}
fn temp_download(name: &str, contents: &[u8]) -> PathBuf {
let path = std::env::temp_dir().join(format!(
"llmman-check-download-test-{}-{name}",
std::process::id()
));
std::fs::write(&path, contents).unwrap();
path
}
fn listed_asset(size: u64, digest: Option<&str>) -> Asset {
Asset {
name: "llama-bin.zip".into(),
browser_download_url: String::new(),
size,
digest: digest.map(String::from),
}
}
fn sha256_hex(contents: &[u8]) -> String {
use sha2::Digest;
hex::encode(sha2::Sha256::digest(contents))
}
fn check_download_error(path: &Path, asset: &Asset) -> String {
format!("{:#}", check_download(path, asset).unwrap_err())
}
#[test]
fn check_download_accepts_the_listed_size_and_digest() {
let path = temp_download("match", b"archive");
let hex = sha256_hex(b"archive");
for digest in [
format!("sha256:{hex}"),
format!("sha256:{}", hex.to_uppercase()),
] {
check_download(&path, &listed_asset(7, Some(&digest))).unwrap();
}
check_download(&path, &listed_asset(7, None)).unwrap();
std::fs::remove_file(&path).unwrap();
}
#[test]
fn check_download_rejects_a_size_the_release_does_not_list() {
let path = temp_download("short", b"<BlockList/>");
assert_eq!(
check_download_error(&path, &listed_asset(18407457, None)),
"llama-bin.zip: downloaded 12 bytes, release lists 18407457"
);
std::fs::remove_file(&path).unwrap();
}
#[test]
fn check_download_rejects_a_digest_the_release_does_not_list() {
let path = temp_download("tampered", b"archive");
let published = sha256_hex(b"another");
assert_eq!(
check_download_error(
&path,
&listed_asset(7, Some(&format!("sha256:{published}")))
),
format!(
"llama-bin.zip: sha256 {} does not match published {published}",
sha256_hex(b"archive")
)
);
assert_eq!(
check_download_error(&path, &listed_asset(7, Some("sha512:ab"))),
"llama-bin.zip: unsupported digest sha512:ab"
);
std::fs::remove_file(&path).unwrap();
}
fn pinned_release(names: impl IntoIterator<Item = String>) -> Release {
Release {
tag_name: build_tag(default_release()).into(),
assets: names
.into_iter()
.map(|name| Asset {
name,
browser_download_url: String::new(),
size: 0,
digest: None,
})
.collect(),
}
}
fn pinned_asset(suffix: &str) -> String {
format!("llama-{}-bin-{suffix}", build_tag(default_release()))
}
#[test]
fn a_major_release_pin_downloads_the_build_it_names() {
assert_eq!(build_tag("v1.0.0-b12359-b1b770d"), "b12359");
for own in ["b12359", "v1.1.0", "latest"] {
assert_eq!(build_tag(own), own);
}
assert!(build_tag(default_release()).starts_with('b'));
}
#[test]
fn primary_asset_matches_only_the_intended_substring() {
let [cpu, vulkan, rocm] = [
"ubuntu-x64.tar.gz",
"ubuntu-vulkan-x64.tar.gz",
"ubuntu-rocm-7.14-x64.tar.gz",
]
.map(pinned_asset);
let release = pinned_release([cpu.clone(), vulkan.clone(), rocm.clone()]);
let find = |pattern: &str| {
let query = AssetQuery {
must_contain: pattern.into(),
companion_must_contain: None,
label: String::new(),
};
find_primary_asset(&release, &query).map(|a| a.name.clone())
};
assert_eq!(find("-bin-ubuntu-x64.tar.gz"), Some(cpu));
assert_eq!(find("-bin-ubuntu-vulkan-x64.tar.gz"), Some(vulkan));
assert_eq!(find("-bin-ubuntu-rocm-"), Some(rocm));
assert_eq!(find("-bin-win-cpu-x64.zip"), None);
}
fn cuda_release(builds: &[(&str, &str)]) -> Release {
pinned_release(builds.iter().flat_map(|(ver, arch)| {
[
format!("cudart-llama-bin-win-cuda-{ver}-{arch}.zip"),
pinned_asset(&format!("win-cuda-{ver}-{arch}.zip")),
]
}))
}
fn selected(release: &Release, query: &AssetQuery) -> (Option<String>, Option<String>) {
let primary = find_primary_asset(release, query);
let companion = primary.and_then(|p| find_companion_asset(release, query, p));
(
primary.map(|a| a.name.clone()),
companion.map(|a| a.name.clone()),
)
}
#[test]
fn primary_cuda_asset_is_never_the_cudart_companion() {
let query = windows_cuda_query(13, "x64");
let companion = "cudart-llama-bin-win-cuda-13.5-x64.zip".to_string();
let primary = pinned_asset("win-cuda-13.5-x64.zip");
let release = pinned_release([companion.clone(), primary.clone()]);
assert!(release.assets[0]
.name
.contains("-bin-win-cuda-13.5-x64.zip"));
assert_eq!(find_primary_asset(&release, &query).unwrap().name, primary);
assert_eq!(
find_companion_asset(&release, &query, &release.assets[1])
.unwrap()
.name,
companion
);
}
const PUBLISHED_CUDA: [(&str, &str); 3] = [("12.4", "x64"), ("13.5", "x64"), ("13.5", "arm64")];
#[test]
fn windows_cuda_arm64_major_13_finds_the_13_5_build_and_companion() {
let release = cuda_release(&PUBLISHED_CUDA);
assert_eq!(
selected(&release, &windows_cuda_query(13, "arm64")),
(
Some(pinned_asset("win-cuda-13.5-arm64.zip")),
Some("cudart-llama-bin-win-cuda-13.5-arm64.zip".into())
)
);
}
#[test]
fn windows_cuda_x64_selects_by_major_and_arch() {
let release = cuda_release(&PUBLISHED_CUDA);
assert_eq!(
selected(&release, &windows_cuda_query(12, "x64")),
(
Some(pinned_asset("win-cuda-12.4-x64.zip")),
Some("cudart-llama-bin-win-cuda-12.4-x64.zip".into())
)
);
assert_eq!(
selected(&release, &windows_cuda_query(13, "x64")),
(
Some(pinned_asset("win-cuda-13.5-x64.zip")),
Some("cudart-llama-bin-win-cuda-13.5-x64.zip".into())
)
);
assert_eq!(
selected(&release, &windows_cuda_query(12, "arm64")),
(None, None)
);
}
#[test]
fn windows_cuda_requires_the_dot_after_the_major() {
let release = cuda_release(&[("130.1", "x64"), ("113.5", "x64")]);
assert_eq!(
selected(&release, &windows_cuda_query(13, "x64")),
(None, None)
);
}
#[test]
fn windows_cuda_picks_the_highest_minor_and_its_companion() {
for builds in [
[("13.5", "x64"), ("13.10", "x64"), ("13.9", "x64")],
[("13.10", "x64"), ("13.9", "x64"), ("13.5", "x64")],
] {
let release = cuda_release(&builds);
assert_eq!(
selected(&release, &windows_cuda_query(13, "x64")),
(
Some(pinned_asset("win-cuda-13.10-x64.zip")),
Some("cudart-llama-bin-win-cuda-13.10-x64.zip".into())
)
);
}
}
#[test]
fn windows_cuda_without_a_matching_companion_still_finds_the_primary() {
let release = pinned_release([pinned_asset("win-cuda-13.5-x64.zip")]);
assert_eq!(
selected(&release, &windows_cuda_query(13, "x64")),
(Some(pinned_asset("win-cuda-13.5-x64.zip")), None)
);
}
#[test]
fn windows_cuda_label_names_the_major_only() {
assert_eq!(windows_cuda_query(13, "arm64").label, "cuda-13");
assert_eq!(windows_cuda_query(12, "x64").label, "cuda-12");
}
#[test]
fn windows_vulkan_matches_each_arch_and_never_the_other() {
let release = pinned_release([
pinned_asset("win-vulkan-x64.zip"),
pinned_asset("win-vulkan-arm64.zip"),
]);
for arch in ["x64", "arm64"] {
assert_eq!(
selected(&release, &windows_vulkan_query(arch)),
(Some(pinned_asset(&format!("win-vulkan-{arch}.zip"))), None)
);
}
for (arch, other) in [("x64", "arm64"), ("arm64", "x64")] {
let only_other = pinned_release([pinned_asset(&format!("win-vulkan-{other}.zip"))]);
assert_eq!(
selected(&only_other, &windows_vulkan_query(arch)),
(None, None)
);
}
assert_eq!(windows_vulkan_query("arm64").label, "vulkan");
}
#[test]
fn primary_asset_without_a_companion_matches_the_only_build() {
let build = pinned_asset("win-vulkan-x64.zip");
let release = pinned_release([build.clone()]);
let query = windows_vulkan_query("x64");
assert_eq!(find_primary_asset(&release, &query).unwrap().name, build);
}
#[test]
fn pointer_asset_detects_a_semver_pointer_release() {
let pointer_release = Release {
tag_name: "v0.3.0".into(),
assets: vec![Asset {
name: "nightly-tag.txt".into(),
browser_download_url: String::new(),
size: 0,
digest: None,
}],
};
assert_eq!(
pointer_asset(&pointer_release).map(|a| a.name.as_str()),
Some("nightly-tag.txt")
);
let binary_release = Release {
tag_name: "b10621".into(),
assets: vec![Asset {
name: "llama-b10621-bin-ubuntu-vulkan-x64.tar.gz".into(),
browser_download_url: String::new(),
size: 0,
digest: None,
}],
};
assert_eq!(
pointer_asset(&binary_release).map(|a| a.name.as_str()),
None
);
let mixed_release = Release {
tag_name: "b10621".into(),
assets: vec![
Asset {
name: "nightly-tag.txt".into(),
browser_download_url: String::new(),
size: 0,
digest: None,
},
Asset {
name: "llama-b10621-bin-ubuntu-vulkan-x64.tar.gz".into(),
browser_download_url: String::new(),
size: 0,
digest: None,
},
],
};
assert_eq!(pointer_asset(&mixed_release).map(|a| a.name.as_str()), None);
}
#[test]
fn parse_pointer_tag_trims_and_rejects_blank_content() {
assert_eq!(parse_pointer_tag("b10621\n"), Some("b10621"));
assert_eq!(parse_pointer_tag(" b10621 "), Some("b10621"));
assert_eq!(parse_pointer_tag(""), None);
assert_eq!(parse_pointer_tag("\n \n"), None);
}
fn pointer_release(tag: &str) -> Release {
Release {
tag_name: tag.into(),
assets: vec![Asset {
name: NIGHTLY_POINTER.into(),
browser_download_url: format!("https://example.invalid/{tag}/{NIGHTLY_POINTER}"),
size: 0,
digest: None,
}],
}
}
fn binary_release(tag: &str) -> Release {
Release {
tag_name: tag.into(),
assets: vec![Asset {
name: format!("llama-{tag}-bin-ubuntu-x64.tar.gz"),
browser_download_url: String::new(),
size: 0,
digest: None,
}],
}
}
#[test]
fn resolve_release_with_dereferences_a_pointer_release() {
let metadata_fetches = std::cell::RefCell::new(Vec::new());
let release = resolve_release_with(
|v| {
metadata_fetches.borrow_mut().push(v.map(str::to_owned));
Ok(match v {
None => pointer_release("v0.3.0"),
Some("b10621") => binary_release("b10621"),
Some(other) => panic!("unexpected tag fetch: {other}"),
})
},
|_url| Ok("b10621\n".into()),
None,
)
.unwrap();
assert_eq!(release.tag_name, "b10621");
assert_eq!(
*metadata_fetches.borrow(),
vec![None, Some("b10621".to_owned())]
);
}
#[test]
fn resolve_release_with_refuses_a_pointer_chain() {
let err = resolve_release_with(
|v| {
Ok(match v {
None => pointer_release("v0.3.0"),
Some(tag) => pointer_release(tag),
})
},
|_url| Ok("b10621\n".into()),
None,
)
.unwrap_err();
let msg = err.to_string();
assert!(msg.contains("v0.3.0"), "missing pointer tag in: {msg}");
assert!(msg.contains("b10621"), "missing dereferenced tag in: {msg}");
assert!(msg.contains("pointer chain"), "unexpected message: {msg}");
}
#[test]
fn resolve_release_with_rejects_a_blank_pointer_file() {
let err = resolve_release_with(
|_v| Ok(pointer_release("v0.3.0")),
|_url| Ok("\n \n".into()),
None,
)
.unwrap_err();
let msg = err.to_string();
assert!(msg.contains("v0.3.0"), "missing pointer tag in: {msg}");
assert!(msg.contains("is empty"), "unexpected message: {msg}");
}
#[test]
fn resolve_release_with_contextualizes_a_failed_dereferenced_fetch() {
let err = resolve_release_with(
|v| match v {
None => Ok(pointer_release("v0.3.0")),
Some(_) => Err(anyhow!("boom")),
},
|_url| Ok("b10621\n".into()),
None,
)
.unwrap_err();
let msg = format!("{err:#}");
assert!(
msg.contains(
"pointer release v0.3.0 names tag b10621, but fetching that release failed"
),
"unexpected message: {msg}"
);
assert!(msg.contains("boom"), "missing root cause in: {msg}");
}
#[test]
fn resolve_release_with_passes_a_binary_release_through() {
let text_fetches = std::cell::Cell::new(0);
let release = resolve_release_with(
|_v| Ok(binary_release("b10621")),
|_url| {
text_fetches.set(text_fetches.get() + 1);
Ok(String::new())
},
None,
)
.unwrap();
assert_eq!(release.tag_name, "b10621");
assert_eq!(text_fetches.get(), 0);
}
#[test]
fn resolve_release_with_passes_a_pinned_binary_tag_through() {
let text_fetches = std::cell::Cell::new(0);
let release = resolve_release_with(
|v| {
assert_eq!(v, Some("b10360"));
Ok(binary_release("b10360"))
},
|_url| {
text_fetches.set(text_fetches.get() + 1);
Ok(String::new())
},
Some("b10360"),
)
.unwrap();
assert_eq!(release.tag_name, "b10360");
assert_eq!(text_fetches.get(), 0);
}
#[test]
fn marker_is_fresh_is_false_for_an_absent_file() {
let path =
std::env::temp_dir().join(format!("llmman-marker-absent-{}", std::process::id()));
let _ = std::fs::remove_file(&path);
assert!(!marker_is_fresh(&path, Duration::from_secs(60)));
}
#[test]
fn marker_is_fresh_is_true_for_a_just_written_file() {
let path = std::env::temp_dir().join(format!("llmman-marker-fresh-{}", std::process::id()));
std::fs::write(&path, b"").unwrap();
let fresh = marker_is_fresh(&path, Duration::from_secs(60));
let _ = std::fs::remove_file(&path);
assert!(fresh);
}
#[test]
fn marker_is_fresh_is_false_for_a_stale_mtime() {
let path = std::env::temp_dir().join(format!("llmman-marker-stale-{}", std::process::id()));
std::fs::write(&path, b"").unwrap();
let file = std::fs::File::options().write(true).open(&path).unwrap();
file.set_modified(std::time::SystemTime::now() - Duration::from_secs(120))
.unwrap();
drop(file);
let fresh = marker_is_fresh(&path, Duration::from_secs(60));
let _ = std::fs::remove_file(&path);
assert!(!fresh);
}
#[test]
fn download_marker_creates_touches_and_removes_the_marker() {
let path = std::env::temp_dir().join(format!(
"llmman-marker-lifecycle-{}/.downloading",
std::process::id()
));
let _ = std::fs::remove_file(&path);
let marker = DownloadMarker::create_at(path.clone());
assert!(path.is_file(), "marker not created at {}", path.display());
std::fs::File::options()
.write(true)
.open(&path)
.unwrap()
.set_modified(std::time::SystemTime::now() - Duration::from_secs(120))
.unwrap();
assert!(!marker_is_fresh(&path, Duration::from_secs(60)));
marker.touch();
assert!(marker_is_fresh(&path, Duration::from_secs(60)));
drop(marker);
assert!(!path.exists(), "marker not removed on drop");
}
fn temp_marker(name: &str) -> PathBuf {
let path = std::env::temp_dir().join(format!(
"llmman-marker-{name}-{}/.downloading",
std::process::id()
));
let _ = std::fs::remove_file(&path);
path
}
fn status_of(path: &Path) -> Option<String> {
marker_status(path, DOWNLOAD_MARKER_STALE_AFTER)
}
fn backdate(path: &Path) {
std::fs::File::options()
.write(true)
.open(path)
.unwrap()
.set_modified(std::time::SystemTime::now() - 2 * DOWNLOAD_MARKER_STALE_AFTER)
.unwrap();
}
#[test]
fn marker_status_reports_the_last_written_text_while_fresh() {
let path = temp_marker("status");
assert_eq!(status_of(&path), None);
let marker = DownloadMarker::create_at(path.clone());
assert_eq!(status_of(&path).as_deref(), Some(""));
marker.set_status("llama.tar.gz: 12 MB / 40 MB (30%)");
assert_eq!(
status_of(&path).as_deref(),
Some("llama.tar.gz: 12 MB / 40 MB (30%)")
);
std::fs::write(&path, b"").unwrap();
marker.touch();
assert_eq!(
status_of(&path).as_deref(),
Some("llama.tar.gz: 12 MB / 40 MB (30%)")
);
marker.set_status("extracting llama.tar.gz");
backdate(&path);
assert_eq!(status_of(&path), None);
drop(marker);
assert_eq!(status_of(&path), None);
}
#[test]
fn keep_alive_heartbeat_refreshes_the_marker_while_work_runs() {
let path = temp_marker("heartbeat");
let marker = DownloadMarker::create_at(path.clone());
marker.set_status("extracting llama.tar.gz");
backdate(&path);
assert_eq!(status_of(&path), None);
let out = marker.keep_alive_every(Duration::from_millis(5), || {
std::thread::sleep(Duration::from_millis(60));
7
});
assert_eq!(out, 7);
assert_eq!(status_of(&path).as_deref(), Some("extracting llama.tar.gz"));
backdate(&path);
std::thread::sleep(Duration::from_millis(30));
assert_eq!(status_of(&path), None);
drop(marker);
assert!(!path.exists());
}
#[test]
fn download_progress_text_includes_a_percentage_only_with_a_known_total() {
assert_eq!(
download_progress_text("x.tar.gz", 30 * 1024 * 1024, 120 * 1024 * 1024),
format!(
"x.tar.gz: {} / {} (25%)",
human_size(30 * 1024 * 1024),
human_size(120 * 1024 * 1024)
)
);
assert_eq!(
download_progress_text("x.tar.gz", 4096, 0),
format!("x.tar.gz: {}", human_size(4096))
);
}
#[test]
fn host_arch_token_returns_a_nonempty_token() {
assert!(!host_arch_token().is_empty());
}
#[test]
fn build_number_compares_correctly_across_a_digit_count_boundary() {
assert!(build_number("b10000") > build_number("b9999"));
assert_eq!(build_number("b10360"), Some(10360));
assert_eq!(build_number("not-a-tag"), None);
}
#[test]
fn cached_in_tag_accepts_a_legacy_cuda_minor_dir() {
let tag = std::env::temp_dir().join(format!("llmman-legacy-cuda-{}", std::process::id()));
let legacy = tag.join("cuda-12.4");
std::fs::create_dir_all(&legacy).unwrap();
std::fs::write(legacy.join("llama-server"), b"").unwrap();
std::fs::write(legacy.join(".llmman-complete"), b"").unwrap();
let found = cached_in_tag(&tag, "cuda-12", "llama-server");
assert_eq!(found, Some(legacy.join("llama-server")));
assert_eq!(cached_in_tag(&tag, "cuda-13", "llama-server"), None);
std::fs::remove_dir_all(&tag).unwrap();
}
#[test]
#[ignore = "hits the network and downloads a real llama.cpp release"]
fn ensure_llama_server_downloads_a_runnable_binary() {
let resolved = ensure_llama_server(None).expect("ensure_llama_server");
assert!(
resolved.bin.is_file(),
"{} is not a file",
resolved.bin.display()
);
let output = std::process::Command::new(&resolved.bin)
.arg("--version")
.output()
.expect("run downloaded llama-server --version");
assert!(
output.status.success(),
"llama-server --version failed: {output:?}"
);
}
}