#![forbid(unsafe_code)]
#![deny(missing_docs)]
mod builder;
pub mod digest;
mod finalization;
mod floor;
mod qualification;
pub use builder::*;
pub use digest::*;
pub use finalization::*;
pub use floor::*;
pub use qualification::*;
use eggpack_contract::{
expected_release_files, validate_release_inventory, DistributionContract, ExpandedAssets,
ExtrasPolicy, ReleaseInventory,
};
pub use eggpack_manifest::{validate_sha256_hex, Sha256Error};
use eggpack_manifest::{
ArchiveMemberRecord, ArtifactForm, ArtifactRecord, BundleRecord, ByteEvidence, ReleaseManifest,
TargetRecord,
};
use serde::{Deserialize, Serialize};
#[cfg(test)]
use std::fs;
use std::{collections::BTreeMap, fmt, path::PathBuf};
#[cfg(test)]
pub(crate) fn test_temp_dir(label: &str) -> PathBuf {
use std::sync::atomic::{AtomicU64, Ordering};
static NEXT: AtomicU64 = AtomicU64::new(0);
loop {
let id = NEXT.fetch_add(1, Ordering::Relaxed);
let path =
std::env::temp_dir().join(format!("eggpack-{label}-{}-{id}", std::process::id()));
match fs::create_dir(&path) {
Ok(()) => return path,
Err(error) if error.kind() == std::io::ErrorKind::AlreadyExists => continue,
Err(error) => panic!("create test temp directory: {error}"),
}
}
}
#[derive(Debug, Clone)]
pub struct FinalizedTargetInput {
pub target: String,
pub release_files: BTreeMap<String, PathBuf>,
pub archive_members: BTreeMap<String, PathBuf>,
}
#[derive(Debug, Clone)]
pub struct FinalizedReleaseInput {
pub product_id: String,
pub release_id: String,
pub source_revision: String,
pub targets: Vec<FinalizedTargetInput>,
pub evidence_references: Vec<String>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CoreError(String);
impl fmt::Display for CoreError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.0)
}
}
impl std::error::Error for CoreError {}
fn err(s: impl Into<String>) -> CoreError {
CoreError(s.into())
}
pub fn host_matches_target(host: HostRequirement, triple: &str) -> bool {
let arch = match host.arch {
HostArch::X86_64 => triple.starts_with("x86_64-"),
HostArch::Aarch64 => triple.starts_with("aarch64-"),
HostArch::Armv7 => triple.starts_with("armv7-"),
};
let os = match host.os {
HostOs::Linux => triple.contains("-linux-"),
HostOs::Macos => triple.ends_with("-apple-darwin"),
HostOs::Windows => triple.contains("-windows-"),
};
arch && os
}
fn valid_tool_version(value: &str) -> bool {
let core = value.split(['-', '+']).next().unwrap_or_default();
let parts: Vec<&str> = core.split('.').collect();
!value.is_empty()
&& value.len() <= 64
&& value
.bytes()
.all(|b| b.is_ascii_alphanumeric() || b".+-_".contains(&b))
&& parts.len() == 3
&& parts
.iter()
.all(|part| !part.is_empty() && part.bytes().all(|b| b.is_ascii_digit()))
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FloorApplicabilityError {
NotGlibcTarget,
NotMacosTarget,
MacosFloorUnderZigbuild,
}
fn floor_applies_to_triple(
floor: &CompatibilityFloor,
triple: &str,
) -> Result<(), FloorApplicabilityError> {
match floor {
CompatibilityFloor::None => Ok(()),
CompatibilityFloor::Glibc { .. } if !triple.contains("-linux-gnu") => {
Err(FloorApplicabilityError::NotGlibcTarget)
}
CompatibilityFloor::Macos { .. } if !triple.ends_with("-apple-darwin") => {
Err(FloorApplicabilityError::NotMacosTarget)
}
_ => Ok(()),
}
}
fn floor_applies_to_strategy(
floor: &CompatibilityFloor,
strategy: BuildStrategy,
) -> Result<(), FloorApplicabilityError> {
match (floor, strategy) {
(CompatibilityFloor::Macos { .. }, BuildStrategy::CargoZigbuild) => {
Err(FloorApplicabilityError::MacosFloorUnderZigbuild)
}
_ => Ok(()),
}
}
pub fn validate_floor_applicability(
floor: &CompatibilityFloor,
strategy: BuildStrategy,
triple: &str,
) -> Result<(), FloorApplicabilityError> {
floor_applies_to_triple(floor, triple)?;
floor_applies_to_strategy(floor, strategy)
}
pub fn validate_policy(policy: &TargetPolicy, triple: &str) -> Result<(), CoreError> {
if policy.toolchain.rust.is_empty()
|| policy.toolchain.rust.len() > 64
|| !policy
.toolchain
.rust
.bytes()
.all(|b| b.is_ascii_alphanumeric() || b".+-_".contains(&b))
|| policy
.toolchain
.cargo_zigbuild
.as_ref()
.is_some_and(|v| !valid_tool_version(v))
|| policy
.toolchain
.zig
.as_ref()
.is_some_and(|v| !valid_tool_version(v))
{
return Err(err(
"toolchain requirement is empty, overlong, or not a complete version",
));
}
match policy.strategy {
BuildStrategy::NativeCargo => {
if policy.toolchain.cargo_zigbuild.is_some() || policy.toolchain.zig.is_some() {
return Err(err(
"native Cargo strategy must not declare cross-build tool versions",
));
}
}
BuildStrategy::CargoZigbuild => {
if policy.toolchain.cargo_zigbuild.is_none() || policy.toolchain.zig.is_none() {
return Err(err(
"cargo-zigbuild strategy requires explicit cargo-zigbuild and Zig versions",
));
}
}
}
if let Err(error) = floor_applies_to_triple(&policy.floor, triple) {
return Err(match error {
FloorApplicabilityError::NotGlibcTarget => {
err("glibc floor applies only to GNU/Linux targets")
}
FloorApplicabilityError::NotMacosTarget => {
err("macOS floor applies only to macOS targets")
}
FloorApplicabilityError::MacosFloorUnderZigbuild => {
err("macOS floor cannot use cargo-zigbuild")
}
});
}
if policy.qualification == Qualification::Native {
let host = policy.qualification_host.unwrap_or(HostRequirement {
os: policy.host_os,
arch: policy.host_arch,
});
if !host_matches_target(host, triple) {
return Err(err(
"native qualification requires a qualification host matching the target OS/arch",
));
}
}
Ok(())
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ExactTagSafetyError {
OutOfBounds,
ControlCharacters,
QueryOrInjectionCharacters,
UnsafePathShape,
UnsafeGitRefPath,
}
const MAX_EXACT_TAG_BYTES: usize = 128;
pub fn validate_exact_tag_safety(tag: &str) -> Result<(), ExactTagSafetyError> {
if tag.is_empty() || tag.len() > MAX_EXACT_TAG_BYTES {
return Err(ExactTagSafetyError::OutOfBounds);
}
if tag.chars().any(char::is_control) {
return Err(ExactTagSafetyError::ControlCharacters);
}
if tag.contains(['?', '#', '@', ' ', '\\', '\'', '"', '`', '$']) {
return Err(ExactTagSafetyError::QueryOrInjectionCharacters);
}
if tag.contains("..") || tag.starts_with('/') || tag.ends_with('/') {
return Err(ExactTagSafetyError::UnsafePathShape);
}
if tag.ends_with('.')
|| tag.contains("@{")
|| tag.contains(['^', ':', '*', '[', '~'])
|| tag.split('/').any(|component| {
component.is_empty() || component.starts_with('.') || component.ends_with(".lock")
})
{
return Err(ExactTagSafetyError::UnsafeGitRefPath);
}
Ok(())
}
pub fn build_manifest(
contract: &DistributionContract,
input: &FinalizedReleaseInput,
) -> Result<ReleaseManifest, CoreError> {
if contract.product.id != input.product_id {
return Err(err("product identity does not match contract"));
}
if input.targets.is_empty() || input.targets.len() > 256 {
return Err(err("target count out of bounds"));
}
let mut target_records = Vec::new();
let mut seen = std::collections::HashSet::new();
for target in &input.targets {
let expanded = contract
.expand(&target.target, &input.release_id)
.map_err(|_| err("target expansion failed"))?;
if !seen.insert(expanded.triple.clone()) {
return Err(err("duplicate canonical target"));
}
let expected = expected_release_files(contract, &target.target, &input.release_id)
.map_err(|_| err("expected inventory derivation failed"))?;
let inventory = ReleaseInventory::new(target.release_files.keys().cloned())
.map_err(|_| err("invalid release inventory"))?;
if !validate_release_inventory(&expected, &inventory, ExtrasPolicy::Exact).is_conformant() {
return Err(err("release inventory is incomplete or contains extras"));
}
let artifact = |name: &str| -> Result<ArtifactRecord, CoreError> {
let path = target
.release_files
.get(name)
.ok_or_else(|| err("required artifact path missing"))?;
let (size, sha256) = file_digest(path)
.map_err(|error| err(format!("finalized file {}", error.reason())))?;
Ok(ArtifactRecord {
name: name.to_string(),
size,
sha256,
})
};
let record_form = match expanded.assets {
ExpandedAssets::Direct(d) => {
if !target.archive_members.is_empty() {
return Err(err("unexpected archive member inputs"));
}
ArtifactForm::Direct {
artifact: artifact(&d.asset_file)?,
install: d.install_name,
}
}
ExpandedAssets::Bundle(b) => {
if !target.archive_members.is_empty() {
return Err(err("unexpected archive member inputs"));
}
ArtifactForm::Bundle {
entries: b
.entries
.iter()
.map(|e| {
Ok(BundleRecord {
artifact: artifact(&e.asset_file)?,
install: e.install_name.clone(),
})
})
.collect::<Result<_, CoreError>>()?,
}
}
ExpandedAssets::Archive(a) => {
if target.archive_members.len() != a.members.len() {
return Err(err("archive member inventory incomplete or has extras"));
}
let members = a
.members
.iter()
.map(|m| {
let p = target
.archive_members
.get(&m.source)
.ok_or_else(|| err("required archive member path missing"))?;
let (size, sha256) = file_digest(p)
.map_err(|error| err(format!("finalized file {}", error.reason())))?;
Ok(ArchiveMemberRecord {
source: m.source.clone(),
install: m.install_name.clone(),
bytes: ByteEvidence { size, sha256 },
})
})
.collect::<Result<_, CoreError>>()?;
ArtifactForm::Archive {
artifact: artifact(&a.archive_file)?,
members,
}
}
};
target_records.push(TargetRecord {
target: expanded.triple,
form: record_form,
});
}
let manifest = ReleaseManifest {
schema_version: 1,
product_id: input.product_id.clone(),
release_id: input.release_id.clone(),
source_revision: input.source_revision.clone(),
targets: target_records,
evidence_references: input.evidence_references.clone(),
};
manifest
.validate()
.map_err(|_| err("constructed manifest violates schema-v1 bounds"))?;
Ok(manifest)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum BuildStrategy {
NativeCargo,
CargoZigbuild,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum HostOs {
Linux,
Macos,
Windows,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum HostArch {
X86_64,
Aarch64,
Armv7,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Qualification {
Native,
DeferredNative,
Emulated,
Structural,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SupportTier {
Required,
NonGating,
Experimental,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct HostRequirement {
pub os: HostOs,
pub arch: HostArch,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ToolchainRequirement {
pub rust: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub cargo_zigbuild: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub zig: Option<String>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
pub enum CompatibilityFloor {
None,
Glibc {
major: u16,
minor: u16,
},
Macos {
major: u16,
minor: u16,
},
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct TargetPolicy {
pub target: String,
pub strategy: BuildStrategy,
pub host_os: HostOs,
pub host_arch: HostArch,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub qualification_host: Option<HostRequirement>,
pub toolchain: ToolchainRequirement,
pub floor: CompatibilityFloor,
pub qualification: Qualification,
pub support: SupportTier,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct PackConfig {
pub schema_version: u32,
pub targets: Vec<TargetPolicy>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ReleasePlan {
pub schema_version: u32,
pub release_id: String,
pub source_revision: String,
pub targets: Vec<PlannedTarget>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct PlannedTarget {
pub target: String,
pub policy: TargetPolicy,
pub artifact_form: PlannedAssetForm,
#[serde(default)]
pub floor_status: FloorVerificationStatus,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum PlannedAssetForm {
Direct,
Bundle,
Archive,
}
impl ReleasePlan {
pub fn validate(&self) -> Result<(), CoreError> {
if self.schema_version != 1
|| self.release_id.is_empty()
|| self.source_revision.is_empty()
|| self.targets.is_empty()
{
return Err(err("invalid ReleasePlan bounds"));
}
for planned in &self.targets {
if planned.floor_status != planned_floor_status(&planned.policy) {
return Err(err(
"ReleasePlan floor status does not match the declared compatibility floor",
));
}
}
Ok(())
}
pub fn to_json(&self) -> Result<String, CoreError> {
self.validate()?;
serde_json::to_string(self).map_err(|_| err("ReleasePlan serialization failed"))
}
}
impl PackConfig {
pub fn from_toml(s: &str) -> Result<Self, CoreError> {
let c: Self = toml::from_str(s).map_err(|_| err("invalid PackConfig TOML"))?;
if c.schema_version != 1 || c.targets.is_empty() {
return Err(err("invalid PackConfig version or empty targets"));
}
if c.targets.len() > 256 {
return Err(err("PackConfig target count out of bounds"));
}
let mut seen = std::collections::HashSet::new();
if c.targets.iter().any(|p| {
p.target.is_empty()
|| !seen.insert(&p.target)
|| p.toolchain.rust.is_empty()
|| p.toolchain.rust.len() > 64
|| (p.strategy == BuildStrategy::CargoZigbuild)
!= p.toolchain.cargo_zigbuild.is_some()
}) {
return Err(err("invalid or duplicate PackConfig target"));
}
Ok(c)
}
pub fn resolve(
&self,
contract: &DistributionContract,
release_id: &str,
source_revision: &str,
selected: &[String],
) -> Result<ReleasePlan, CoreError> {
if self.schema_version != 1 {
return Err(err("unsupported PackConfig version"));
}
let mut policies = BTreeMap::new();
for p in &self.targets {
let t = contract
.resolve(&p.target)
.map_err(|_| err("PackConfig contains unsupported target"))?;
validate_policy(p, &t.triple)?;
if policies.insert(t.triple.clone(), p).is_some() {
return Err(err("duplicate canonical policy target"));
}
}
let mut targets = Vec::new();
let mut seen = std::collections::HashSet::new();
for s in selected {
let t = contract
.resolve(s)
.map_err(|_| err("unknown selected target"))?;
if !seen.insert(t.triple.clone()) {
return Err(err("duplicate selected target"));
}
let mut policy = policies
.get(&t.triple)
.copied()
.ok_or_else(|| err("selected target has no policy"))?
.clone();
policy.target = t.triple.clone();
let artifact_form = match &t.asset {
eggpack_contract::AssetForm::Direct { .. } => PlannedAssetForm::Direct,
eggpack_contract::AssetForm::Bundle { .. } => PlannedAssetForm::Bundle,
eggpack_contract::AssetForm::Archive { .. } => PlannedAssetForm::Archive,
};
let floor_status = planned_floor_status(&policy);
targets.push(PlannedTarget {
target: t.triple.clone(),
policy,
artifact_form,
floor_status,
});
}
if targets.is_empty() {
return Err(err("no selected targets"));
}
targets.sort_by(|a, b| a.target.cmp(&b.target));
Ok(ReleasePlan {
schema_version: 1,
release_id: release_id.into(),
source_revision: source_revision.into(),
targets,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_temp_roots_are_unique_under_parallel_and_repeated_calls() {
let existing = test_temp_dir("stale");
let next = test_temp_dir("stale");
assert_ne!(existing, next);
let workers = (0..16)
.map(|_| std::thread::spawn(|| test_temp_dir("parallel")))
.collect::<Vec<_>>();
let roots = workers
.into_iter()
.map(|worker| worker.join().unwrap())
.collect::<std::collections::BTreeSet<_>>();
assert_eq!(roots.len(), 16);
for path in roots.into_iter().chain([existing, next]) {
fs::remove_dir_all(path).unwrap();
}
}
#[test]
fn pack_config_resolves_targets_in_canonical_order() {
let contract = DistributionContract::parse_toml_str(include_str!(
"../../eggpack-contract/tests/fixtures/simple-direct.toml"
))
.unwrap();
let config = PackConfig {
schema_version: 1,
targets: vec![TargetPolicy {
target: "x86_64-unknown-linux-gnu".into(),
strategy: BuildStrategy::NativeCargo,
host_os: HostOs::Linux,
host_arch: HostArch::X86_64,
qualification_host: None,
toolchain: ToolchainRequirement {
rust: "1.89.0".into(),
cargo_zigbuild: None,
zig: None,
},
floor: CompatibilityFloor::None,
qualification: Qualification::Native,
support: SupportTier::Required,
}],
};
let selected = vec!["linux-x64".into()];
assert_eq!(
config
.resolve(&contract, "1.2.6", "abc", &selected)
.unwrap()
.targets[0]
.target,
"x86_64-unknown-linux-gnu"
);
assert!(config
.resolve(&contract, "1.2.6", "abc", &["nope".into()])
.is_err());
let mut invalid = config.clone();
invalid.targets[0].qualification = Qualification::Emulated;
assert!(invalid
.resolve(&contract, "1.2.6", "abc", &selected)
.is_ok());
invalid.targets[0].qualification = Qualification::Native;
invalid.targets[0].host_arch = HostArch::Aarch64;
assert!(invalid
.resolve(&contract, "1.2.6", "abc", &selected)
.is_err());
}
#[test]
fn a_native_cargo_glibc_floor_is_recorded_in_the_plan_and_still_resolves() {
let contract = DistributionContract::parse_toml_str(include_str!(
"../../eggpack-contract/tests/fixtures/simple-direct.toml"
))
.unwrap();
let config = PackConfig {
schema_version: 1,
targets: vec![TargetPolicy {
target: "x86_64-unknown-linux-gnu".into(),
strategy: BuildStrategy::NativeCargo,
host_os: HostOs::Linux,
host_arch: HostArch::X86_64,
qualification_host: None,
toolchain: ToolchainRequirement {
rust: "1.89.0".into(),
cargo_zigbuild: None,
zig: None,
},
floor: CompatibilityFloor::Glibc {
major: 2,
minor: 17,
},
qualification: Qualification::Native,
support: SupportTier::Required,
}],
};
let selected = vec!["linux-x64".into()];
let plan = config
.resolve(&contract, "1.2.6", "abc", &selected)
.unwrap();
assert_eq!(
plan.targets[0].policy.floor,
CompatibilityFloor::Glibc {
major: 2,
minor: 17
}
);
assert_eq!(
plan.targets[0].floor_status,
FloorVerificationStatus::Unverified(FloorUnverifiedReason::PendingInspection)
);
assert!(plan.validate().is_ok());
assert!(plan.to_json().is_ok());
let mut contradictory = plan.clone();
contradictory.targets[0].floor_status = FloorVerificationStatus::NotDeclared;
assert!(contradictory.validate().is_err());
assert!(contradictory.to_json().is_err());
let mut cross_tool = config.clone();
cross_tool.targets[0].strategy = BuildStrategy::CargoZigbuild;
cross_tool.targets[0].toolchain.cargo_zigbuild = Some("0.23.3".into());
cross_tool.targets[0].toolchain.zig = Some("0.14.1".into());
let plan = cross_tool
.resolve(&contract, "1.2.6", "abc", &selected)
.unwrap();
assert_eq!(
plan.targets[0].floor_status,
FloorVerificationStatus::ToolchainBound
);
assert!(plan.validate().is_ok());
}
#[test]
fn pack_config_toml_is_versioned_bounded_and_rejects_unknown_fields() {
let source = r#"schema_version=1
[[targets]]
target="x86_64-unknown-linux-gnu"
strategy="native_cargo"
host_os="linux"
host_arch="x86_64"
toolchain={rust="1.89.0"}
floor={kind="none"}
qualification="native"
support="required"
"#;
assert!(PackConfig::from_toml(source).is_ok());
assert!(
PackConfig::from_toml(&source.replace("support=", "unexpected=1\nsupport=")).is_err()
);
assert!(
PackConfig::from_toml(&source.replace("schema_version=1", "schema_version=2")).is_err()
);
}
#[test]
fn native_qualification_is_admitted_for_cross_tool_builds_on_a_matching_host() {
let contract = DistributionContract::parse_toml_str(include_str!(
"../../eggpack-contract/tests/fixtures/simple-direct.toml"
))
.unwrap();
let selected = vec!["linux-x64".into()];
let cross = TargetPolicy {
target: "x86_64-unknown-linux-gnu".into(),
strategy: BuildStrategy::CargoZigbuild,
host_os: HostOs::Linux,
host_arch: HostArch::X86_64,
qualification_host: None,
toolchain: ToolchainRequirement {
rust: "1.89.0".into(),
cargo_zigbuild: Some("0.23.3".into()),
zig: Some("0.14.1".into()),
},
floor: CompatibilityFloor::Glibc {
major: 2,
minor: 17,
},
qualification: Qualification::Native,
support: SupportTier::Required,
};
let resolve = |policy: &TargetPolicy| {
PackConfig {
schema_version: 1,
targets: vec![policy.clone()],
}
.resolve(&contract, "1.2.6", "abc", &selected)
};
let release = resolve(&cross).unwrap();
let planned = &release.targets[0];
assert_eq!(planned.target, "x86_64-unknown-linux-gnu");
assert_eq!(planned.policy.strategy, BuildStrategy::CargoZigbuild);
assert_eq!(planned.policy.qualification, Qualification::Native);
assert_eq!(
planned.policy.floor,
CompatibilityFloor::Glibc {
major: 2,
minor: 17
}
);
assert_eq!(
planned.policy.toolchain.cargo_zigbuild.as_deref(),
Some("0.23.3")
);
assert_eq!(planned.policy.toolchain.zig.as_deref(), Some("0.14.1"));
let mut explicit = cross.clone();
explicit.qualification_host = Some(HostRequirement {
os: HostOs::Linux,
arch: HostArch::X86_64,
});
let explicit = resolve(&explicit).unwrap();
assert_eq!(
explicit.targets[0].policy.qualification_host,
Some(HostRequirement {
os: HostOs::Linux,
arch: HostArch::X86_64,
})
);
assert!(host_matches_target(
explicit.targets[0]
.policy
.qualification_host
.expect("explicit qualification host"),
&explicit.targets[0].target
));
let mut wrong_arch = cross.clone();
wrong_arch.qualification_host = Some(HostRequirement {
os: HostOs::Linux,
arch: HostArch::Aarch64,
});
assert!(resolve(&wrong_arch).is_err());
let mut wrong_build_arch = cross.clone();
wrong_build_arch.host_arch = HostArch::Aarch64;
assert!(resolve(&wrong_build_arch).is_err());
let mut wrong_os = cross.clone();
wrong_os.qualification_host = Some(HostRequirement {
os: HostOs::Macos,
arch: HostArch::X86_64,
});
assert!(resolve(&wrong_os).is_err());
for toolchain in [
ToolchainRequirement {
rust: "1.89.0".into(),
cargo_zigbuild: Some("0.23.3".into()),
zig: None,
},
ToolchainRequirement {
rust: "1.89.0".into(),
cargo_zigbuild: None,
zig: Some("0.14.1".into()),
},
ToolchainRequirement {
rust: "1.89.0".into(),
cargo_zigbuild: Some("0.23.3".into()),
zig: Some("0.14.1".into()),
},
] {
let mut native = cross.clone();
native.strategy = BuildStrategy::NativeCargo;
native.floor = CompatibilityFloor::None;
native.toolchain = toolchain;
assert!(resolve(&native).is_err());
}
let mut glibc_on_macos = cross.clone();
glibc_on_macos.target = "aarch64-apple-darwin".into();
glibc_on_macos.host_os = HostOs::Macos;
glibc_on_macos.host_arch = HostArch::Aarch64;
assert!(PackConfig {
schema_version: 1,
targets: vec![glibc_on_macos],
}
.resolve(&contract, "1.2.6", "abc", &["macos-arm64".into()])
.is_err());
let mut macos_floor_on_linux = cross.clone();
macos_floor_on_linux.floor = CompatibilityFloor::Macos {
major: 13,
minor: 0,
};
assert!(resolve(&macos_floor_on_linux).is_err());
}
#[test]
fn zig_version_is_required_for_zigbuild_and_forbidden_for_native() {
let contract = DistributionContract::parse_toml_str(include_str!(
"../../eggpack-contract/tests/fixtures/simple-direct.toml"
))
.unwrap();
let selected = vec!["linux-x64".into()];
let base = TargetPolicy {
target: "x86_64-unknown-linux-gnu".into(),
strategy: BuildStrategy::CargoZigbuild,
host_os: HostOs::Linux,
host_arch: HostArch::X86_64,
qualification_host: None,
toolchain: ToolchainRequirement {
rust: "1.89.0".into(),
cargo_zigbuild: Some("0.23.3".into()),
zig: Some("0.14.1".into()),
},
floor: CompatibilityFloor::Glibc {
major: 2,
minor: 17,
},
qualification: Qualification::Structural,
support: SupportTier::Required,
};
let config = PackConfig {
schema_version: 1,
targets: vec![base.clone()],
};
assert!(config.resolve(&contract, "1.2.6", "abc", &selected).is_ok());
let historical = r#"schema_version=1
[[targets]]
target="x86_64-unknown-linux-gnu"
strategy="cargo_zigbuild"
host_os="linux"
host_arch="x86_64"
toolchain={rust="1.89.0", cargo_zigbuild="0.23.3"}
floor={kind="glibc", major=2, minor=17}
qualification="structural"
support="required"
"#;
let parsed = PackConfig::from_toml(historical).unwrap();
assert!(parsed.targets[0].toolchain.zig.is_none());
assert!(parsed
.resolve(&contract, "1.2.6", "abc", &selected)
.is_err());
let mut missing_zigbuild = base.clone();
missing_zigbuild.toolchain.cargo_zigbuild = None;
assert!(PackConfig {
schema_version: 1,
targets: vec![missing_zigbuild],
}
.resolve(&contract, "1.2.6", "abc", &selected)
.is_err());
let mut missing_zig = base.clone();
missing_zig.toolchain.zig = None;
assert!(PackConfig {
schema_version: 1,
targets: vec![missing_zig],
}
.resolve(&contract, "1.2.6", "abc", &selected)
.is_err());
for toolchain in [
ToolchainRequirement {
rust: "1.89.0".into(),
cargo_zigbuild: Some("0.23.3".into()),
zig: None,
},
ToolchainRequirement {
rust: "1.89.0".into(),
cargo_zigbuild: None,
zig: Some("0.14.1".into()),
},
ToolchainRequirement {
rust: "1.89.0".into(),
cargo_zigbuild: Some("0.23.3".into()),
zig: Some("0.14.1".into()),
},
] {
let mut native = base.clone();
native.strategy = BuildStrategy::NativeCargo;
native.floor = CompatibilityFloor::None;
native.qualification = Qualification::Native;
native.toolchain = toolchain;
assert!(PackConfig {
schema_version: 1,
targets: vec![native],
}
.resolve(&contract, "1.2.6", "abc", &selected)
.is_err());
}
let mut bad_grammar = base;
bad_grammar.toolchain.zig = Some("0.14.1/../../evil".into());
assert!(PackConfig {
schema_version: 1,
targets: vec![bad_grammar],
}
.resolve(&contract, "1.2.6", "abc", &selected)
.is_err());
}
#[test]
fn manifest_builder_hashes_only_explicit_contract_paths() {
let contract = DistributionContract::parse_toml_str(include_str!(
"../../eggpack-contract/tests/fixtures/simple-direct.toml"
))
.unwrap();
let dir = test_temp_dir("core-test");
let names = [
"eggsact-1.2.6-x86_64-unknown-linux-gnu",
"eggsact-1.2.6-x86_64-unknown-linux-gnu.sha256",
];
let mut files = BTreeMap::new();
for n in names {
let p = dir.join(n);
fs::write(&p, b"abc").unwrap();
files.insert(n.to_string(), p);
}
let input = FinalizedReleaseInput {
product_id: "eggsact".into(),
release_id: "1.2.6".into(),
source_revision: "a".repeat(40),
targets: vec![FinalizedTargetInput {
target: "linux-x64".into(),
release_files: files,
archive_members: BTreeMap::new(),
}],
evidence_references: vec![],
};
let m = build_manifest(&contract, &input).unwrap();
assert_eq!(m.targets[0].target, "x86_64-unknown-linux-gnu");
assert_eq!(
m.targets[0].form,
ArtifactForm::Direct {
artifact: ArtifactRecord {
name: names[0].into(),
size: 3,
sha256: "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
.into()
},
install: "eggsact".into()
}
);
fs::remove_dir_all(dir).unwrap();
}
#[test]
fn manifest_builder_refuses_artifacts_that_are_not_regular_non_empty_files() {
let contract = DistributionContract::parse_toml_str(include_str!(
"../../eggpack-contract/tests/fixtures/simple-direct.toml"
))
.unwrap();
let dir = test_temp_dir("core-digest-policy");
let names = [
"eggsact-1.2.6-x86_64-unknown-linux-gnu",
"eggsact-1.2.6-x86_64-unknown-linux-gnu.sha256",
];
let mut files = BTreeMap::new();
for name in names {
let path = dir.join(name);
fs::write(&path, b"abc").unwrap();
files.insert(name.to_string(), path);
}
let input = FinalizedReleaseInput {
product_id: "eggsact".into(),
release_id: "1.2.6".into(),
source_revision: "a".repeat(40),
targets: vec![FinalizedTargetInput {
target: "linux-x64".into(),
release_files: files,
archive_members: BTreeMap::new(),
}],
evidence_references: vec![],
};
assert!(build_manifest(&contract, &input).is_ok());
fs::write(dir.join(names[0]), b"").unwrap();
assert!(build_manifest(&contract, &input).is_err());
fs::remove_file(dir.join(names[0])).unwrap();
assert!(build_manifest(&contract, &input).is_err());
fs::remove_dir_all(dir).unwrap();
}
#[cfg(unix)]
#[test]
fn manifest_builder_refuses_a_symlinked_artifact() {
let contract = DistributionContract::parse_toml_str(include_str!(
"../../eggpack-contract/tests/fixtures/simple-direct.toml"
))
.unwrap();
let dir = test_temp_dir("core-digest-symlink");
let names = [
"eggsact-1.2.6-x86_64-unknown-linux-gnu",
"eggsact-1.2.6-x86_64-unknown-linux-gnu.sha256",
];
let mut files = BTreeMap::new();
for name in names {
let path = dir.join(name);
fs::write(&path, b"abc").unwrap();
files.insert(name.to_string(), path);
}
let input = FinalizedReleaseInput {
product_id: "eggsact".into(),
release_id: "1.2.6".into(),
source_revision: "a".repeat(40),
targets: vec![FinalizedTargetInput {
target: "linux-x64".into(),
release_files: files,
archive_members: BTreeMap::new(),
}],
evidence_references: vec![],
};
let artifact = dir.join(names[0]);
let real = dir.join("real-artifact");
fs::rename(&artifact, &real).unwrap();
std::os::unix::fs::symlink(&real, &artifact).unwrap();
assert!(build_manifest(&contract, &input).is_err());
fs::remove_dir_all(dir).unwrap();
}
#[test]
fn bundle_and_archive_inputs_preserve_contract_relationships() {
for (fixture, release, product, target) in [
(
include_str!("../../eggpack-contract/tests/fixtures/codegg-bundle.toml"),
"2.4.0",
"codegg",
"linux-x64",
),
(
include_str!("../../eggpack-contract/tests/fixtures/egress-archive.toml"),
"3.1.0",
"egress",
"linux-x64",
),
] {
let contract = DistributionContract::parse_toml_str(fixture).unwrap();
let expected = expected_release_files(&contract, target, release).unwrap();
let dir = test_temp_dir(&format!("layout-test-{product}"));
let mut files = BTreeMap::new();
for item in expected {
let path = dir.join(&item.file_name);
fs::write(&path, b"asset").unwrap();
files.insert(item.file_name, path);
}
let expanded = contract.expand(target, release).unwrap();
let members = match expanded.assets {
ExpandedAssets::Archive(a) => a
.members
.into_iter()
.map(|m| {
let path = dir.join(format!("member-{}", m.source.replace('/', "_")));
fs::write(&path, b"member").unwrap();
(m.source, path)
})
.collect(),
_ => BTreeMap::new(),
};
let input = FinalizedReleaseInput {
product_id: product.into(),
release_id: release.into(),
source_revision: "c".repeat(40),
targets: vec![FinalizedTargetInput {
target: target.into(),
release_files: files,
archive_members: members,
}],
evidence_references: vec![],
};
let manifest = build_manifest(&contract, &input).unwrap();
match &manifest.targets[0].form {
ArtifactForm::Bundle { .. } if product == "codegg" => (),
ArtifactForm::Archive { members, .. } if product == "egress" => {
assert_eq!(members.len(), 2)
}
_ => panic!("contract form was not preserved"),
}
fs::remove_dir_all(dir).unwrap();
}
}
#[test]
fn manifest_builder_rejects_missing_or_extra_contract_inventory() {
let contract = DistributionContract::parse_toml_str(include_str!(
"../../eggpack-contract/tests/fixtures/simple-direct.toml"
))
.unwrap();
let dir = test_temp_dir("core-negative");
let mut files = BTreeMap::new();
for name in [
"eggsact-1.2.6-x86_64-unknown-linux-gnu",
"eggsact-1.2.6-x86_64-unknown-linux-gnu.sha256",
] {
let p = dir.join(name);
fs::write(&p, b"x").unwrap();
files.insert(name.to_string(), p);
}
let mut input = FinalizedReleaseInput {
product_id: "eggsact".into(),
release_id: "1.2.6".into(),
source_revision: "a".repeat(40),
targets: vec![FinalizedTargetInput {
target: "linux-x64".into(),
release_files: files,
archive_members: BTreeMap::new(),
}],
evidence_references: vec![],
};
input.targets[0]
.release_files
.remove("eggsact-1.2.6-x86_64-unknown-linux-gnu.sha256");
assert!(build_manifest(&contract, &input).is_err());
input.targets[0]
.release_files
.insert("unexpected.file".into(), dir.join("unused"));
assert!(build_manifest(&contract, &input).is_err());
fs::remove_dir_all(dir).unwrap();
}
}