@@ -1,0 +1,167 @@
use reqwest::header::{HeaderValue, AUTHORIZATION};
use reqwest::multipart;
use std::path::{Path, PathBuf};
use crate::runner::RunnerConfig;
/// Specification for an artifact to upload after job execution.
#[derive(Debug, Clone)]
pub struct ArtifactSpec {
pub name: String,
pub path: String,
}
const MAX_ARTIFACT_SIZE: u64 = 100 * 1024 * 1024; // 100MB
/// Parse artifact specs from the claim response JSON.
pub fn parse_specs(job: &serde_json::Value) -> Vec<ArtifactSpec> {
let Some(specs) = job.get("artifact_specs").and_then(|v| v.as_array()) else {
return Vec::new();
};
specs
.iter()
.filter_map(|spec| {
let name = spec.get("name")?.as_str()?.to_string();
let path = spec.get("path")?.as_str()?.to_string();
Some(ArtifactSpec { name, path })
})
.collect()
}
/// Upload all artifacts matching the specs from the workspace directory.
///
/// Resolves paths relative to workspace, supports glob patterns.
/// Skips files over MAX_ARTIFACT_SIZE with a warning.
/// Returns the number of successfully uploaded artifacts.
pub async fn upload_artifacts(
config: &RunnerConfig,
job_id: &str,
workspace: &Path,
specs: &[ArtifactSpec],
) -> u32 {
if specs.is_empty() {
return 0;
}
let client = reqwest::Client::new();
let mut uploaded = 0u32;
for spec in specs {
let files = resolve_paths(workspace, &spec.path);
if files.is_empty() {
eprintln!(
" [artifacts] Warning: no files matched '{}' for artifact '{}'",
spec.path, spec.name
);
continue;
}
for file_path in &files {
let artifact_name = if files.len() > 1 {
// Multiple files: use relative path as name
let rel = file_path
.strip_prefix(workspace)
.unwrap_or(file_path)
.to_string_lossy()
.to_string();
format!("{}/{}", spec.name, rel)
} else {
spec.name.clone()
};
match upload_single(&client, config, job_id, file_path, &artifact_name).await {
Ok(()) => {
eprintln!(" [artifacts] Uploaded '{}'", artifact_name);
uploaded += 1;
}
Err(e) => {
eprintln!(" [artifacts] Failed to upload '{}': {}", artifact_name, e);
}
}
}
}
uploaded
}
/// Resolve a path pattern relative to workspace.
/// Supports simple glob patterns (*, **).
fn resolve_paths(workspace: &Path, pattern: &str) -> Vec<PathBuf> {
let full_pattern = workspace.join(pattern);
let pattern_str = full_pattern.to_string_lossy();
// Check if it's a glob pattern
if pattern_str.contains('*') || pattern_str.contains('?') || pattern_str.contains('[') {
match glob::glob(&pattern_str) {
Ok(paths) => paths
.filter_map(Result::ok)
.filter(|p| p.is_file())
.collect(),
Err(e) => {
eprintln!(" [artifacts] Invalid glob pattern '{}': {}", pattern, e);
Vec::new()
}
}
} else {
// Literal path
let path = workspace.join(pattern);
if path.is_file() {
vec![path]
} else {
Vec::new()
}
}
}
/// Upload a single file as a multipart form to the artifact endpoint.
async fn upload_single(
client: &reqwest::Client,
config: &RunnerConfig,
job_id: &str,
file_path: &Path,
artifact_name: &str,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
// Check file size
let metadata = std::fs::metadata(file_path)?;
if metadata.len() > MAX_ARTIFACT_SIZE {
return Err(format!(
"file too large ({} bytes, max {} bytes)",
metadata.len(),
MAX_ARTIFACT_SIZE
)
.into());
}
let file_bytes = std::fs::read(file_path)?;
let url = config.api_url(&format!("/runners/jobs/{job_id}/artifacts"));
// Try multipart upload first
let file_part = multipart::Part::bytes(file_bytes)
.file_name(artifact_name.to_string())
.mime_str("application/octet-stream")?;
let form = multipart::Form::new()
.text("name", artifact_name.to_string())
.part("file", file_part);
let resp = client
.post(&url)
.header(
AUTHORIZATION,
HeaderValue::from_str(&config.auth_header())?,
)
.multipart(form)
.send()
.await?;
let status = resp.status();
if status.is_success() {
Ok(())
} else {
let body = resp.text().await.unwrap_or_default();
Err(format!("upload failed ({status}): {body}").into())
}
}