service_source_lock_command.rs (81341B)
1 use std::{ 2 collections::BTreeSet, 3 ffi::OsStr, 4 fmt, fs, 5 io::{Read as _, Seek as _, SeekFrom, Write as _}, 6 path::{Path, PathBuf}, 7 process::{Command, Stdio}, 8 }; 9 10 use serde::Deserialize; 11 use sha2::{Digest as _, Sha256}; 12 use tempfile::{NamedTempFile, TempDir}; 13 use walkdir::WalkDir; 14 15 use crate::build_output::is_build_output_directory; 16 use crate::exact_tree_archive; 17 use crate::service_source_lock::{ContractVersions, LIB_REPOSITORY}; 18 use crate::service_source_lock_nix::{validate_bound_nix_lock, validate_bound_nix_material}; 19 use crate::service_source_lock_v4::{ 20 LOCK_FILENAME, MAX_LOCK_BYTES, PREDECESSOR_LOCK_FILENAMES, ServiceSourceLockV4, 21 ServiceSourceLockV4Parts, validate_lib_compiler_inputs, validate_toolchain_bytes, 22 }; 23 24 const CATALOG_RELATIVE: &str = "contracts/crates/catalog.v2.toml"; 25 const CARGO_MANIFEST: &str = "Cargo.toml"; 26 const CARGO_LOCK: &str = "Cargo.lock"; 27 const FLAKE_NIX: &str = "flake.nix"; 28 const FLAKE_LOCK: &str = "flake.lock"; 29 const RUST_TOOLCHAIN: &str = "rust-toolchain.toml"; 30 const LIB_VERSION_REQUIREMENT: &str = "=0.1.0-alpha"; 31 const HOST_PACKAGE: &str = "radroots_service_host"; 32 const HOST_FEATURE_PROFILE: &str = "service-host"; 33 const MAX_MANIFEST_BYTES: usize = 1_048_576; 34 const MAX_CARGO_LOCK_BYTES: usize = 16_777_216; 35 const MAX_FLAKE_LOCK_BYTES: usize = 4_194_304; 36 const MAX_FLAKE_NIX_BYTES: usize = 1_048_576; 37 const MAX_TOOLCHAIN_BYTES: usize = 65_536; 38 const MAX_CATALOG_BYTES: usize = 4_194_304; 39 const MAX_GIT_OUTPUT_BYTES: usize = 65_536; 40 const MAX_ARCHIVE_BYTES: u64 = 1_073_741_824; 41 const MAX_TREE_ENTRIES: usize = 16_384; 42 const MAX_MANIFESTS: usize = 512; 43 44 #[derive(Clone, Copy, Debug, Eq, PartialEq)] 45 pub(crate) enum CommandMode { 46 Check, 47 Write, 48 Prepare, 49 } 50 51 #[derive(Clone, Copy, Debug, Eq, PartialEq)] 52 enum CommandError { 53 InvalidServiceRoot, 54 DirtyServiceSource, 55 InvalidServiceMetadata, 56 InvalidCargoManifest, 57 InvalidCargoLock, 58 InvalidArtifactContract, 59 InvalidNixMaterial, 60 InvalidFlakeLock, 61 InvalidToolchain, 62 InvalidSourceArchive, 63 UnreachableRevision, 64 InvalidSourceLock, 65 StaleSourceLock, 66 WriteFailure, 67 } 68 69 impl fmt::Display for CommandError { 70 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { 71 formatter.write_str(match self { 72 Self::InvalidServiceRoot => "service source-lock root is invalid", 73 Self::DirtyServiceSource => "service source contains an ungoverned change", 74 Self::InvalidServiceMetadata => "service source-lock metadata is invalid", 75 Self::InvalidCargoManifest => "service Cargo manifest dependency is invalid", 76 Self::InvalidCargoLock => "service Cargo lock is invalid", 77 Self::InvalidArtifactContract => "service artifact contract is invalid", 78 Self::InvalidNixMaterial => "service bound Nix material is invalid", 79 Self::InvalidFlakeLock => "service flake lock is invalid", 80 Self::InvalidToolchain => "service Rust toolchain is invalid", 81 Self::InvalidSourceArchive => "Lib source archive is invalid", 82 Self::UnreachableRevision => "Lib revision is not remotely reachable", 83 Self::InvalidSourceLock => "service source lock is invalid", 84 Self::StaleSourceLock => "service source lock is stale", 85 Self::WriteFailure => "service source lock could not be updated", 86 }) 87 } 88 } 89 90 impl std::error::Error for CommandError {} 91 92 #[derive(Clone, Debug, Eq, PartialEq)] 93 struct ServiceMetadata { 94 service: String, 95 contract_versions: ContractVersions, 96 } 97 98 #[derive(Clone, Debug, Eq, PartialEq)] 99 struct NixMaterialEvidence { 100 lib_revision: String, 101 flake_lock_sha256: String, 102 } 103 104 #[derive(Debug, Deserialize)] 105 struct CargoLockDocument { 106 #[serde(default)] 107 package: Vec<CargoLockPackage>, 108 } 109 110 #[derive(Debug, Deserialize)] 111 struct CargoLockPackage { 112 name: String, 113 version: String, 114 source: Option<String>, 115 } 116 117 struct ArchiveEvidence { 118 revision: String, 119 archive_sha256: String, 120 catalog_sha256: String, 121 package_names: BTreeSet<String>, 122 } 123 124 trait RevisionReachability { 125 fn verify(&self, revision: &str) -> Result<(), CommandError>; 126 } 127 128 struct PublicLibRemote; 129 130 impl RevisionReachability for PublicLibRemote { 131 fn verify(&self, revision: &str) -> Result<(), CommandError> { 132 let repository = TempDir::new().map_err(|_| CommandError::UnreachableRevision)?; 133 git_status(repository.path(), ["init", "--bare", "--quiet"]) 134 .map_err(|_| CommandError::UnreachableRevision)?; 135 let status = Command::new("git") 136 .args(["fetch", "--quiet", "--no-tags", "--depth=1", LIB_REPOSITORY]) 137 .arg(revision) 138 .current_dir(repository.path()) 139 .stdin(Stdio::null()) 140 .stdout(Stdio::null()) 141 .stderr(Stdio::null()) 142 .status() 143 .map_err(|_| CommandError::UnreachableRevision)?; 144 if !status.success() { 145 return Err(CommandError::UnreachableRevision); 146 } 147 git_status(repository.path(), ["cat-file", "-e", revision]) 148 .map_err(|_| CommandError::UnreachableRevision) 149 } 150 } 151 152 pub(crate) fn run( 153 mode: CommandMode, 154 service_root: &Path, 155 source_archive: &Path, 156 ) -> Result<(), String> { 157 run_with(mode, service_root, source_archive, &PublicLibRemote) 158 .map_err(|error| error.to_string()) 159 } 160 161 fn run_with( 162 mode: CommandMode, 163 service_root: &Path, 164 source_archive: &Path, 165 reachability: &dyn RevisionReachability, 166 ) -> Result<(), CommandError> { 167 let service_root = validate_service_root(service_root)?; 168 for predecessor in PREDECESSOR_LOCK_FILENAMES { 169 match fs::symlink_metadata(service_root.join(predecessor)) { 170 Err(error) if error.kind() == std::io::ErrorKind::NotFound => {} 171 _ => return Err(CommandError::InvalidSourceLock), 172 } 173 } 174 let initial_head = service_head(&service_root)?; 175 let prepared = mode == CommandMode::Prepare; 176 validate_service_cleanliness(&service_root, prepared)?; 177 let initial_index = if prepared { 178 Some(service_index(&service_root)?) 179 } else { 180 None 181 }; 182 183 let root_manifest = read_bounded_regular( 184 &service_root.join(CARGO_MANIFEST), 185 MAX_MANIFEST_BYTES, 186 CommandError::InvalidCargoManifest, 187 )?; 188 let root_manifest = parse_toml(&root_manifest, CommandError::InvalidCargoManifest)?; 189 let metadata = parse_service_metadata(&root_manifest)?; 190 let revision = validate_cargo_manifests(&service_root, None)?; 191 192 let nix = read_nix_material(&service_root)?; 193 if nix.lib_revision != revision { 194 return Err(CommandError::InvalidNixMaterial); 195 } 196 197 validate_toolchain(&service_root)?; 198 let archive = validate_archive(source_archive, &revision)?; 199 let confirmed_revision = validate_cargo_manifests(&service_root, Some(&archive.package_names))?; 200 if confirmed_revision != revision { 201 return Err(CommandError::InvalidCargoManifest); 202 } 203 let cargo_lock = read_bounded_regular( 204 &service_root.join(CARGO_LOCK), 205 MAX_CARGO_LOCK_BYTES, 206 CommandError::InvalidCargoLock, 207 )?; 208 validate_cargo_lock(&cargo_lock, &revision, &archive.package_names)?; 209 let cargo_lock_sha256 = sha256(&cargo_lock); 210 reachability.verify(&archive.revision)?; 211 let artifact_path = format!( 212 "contracts/release/{}-artifact-contract.v4.json", 213 metadata.service 214 ); 215 let artifact_contract = if prepared { 216 let specification = format!(":{artifact_path}"); 217 git_stdout(&service_root, ["show", &specification], MAX_MANIFEST_BYTES) 218 .map_err(|_| CommandError::InvalidArtifactContract)? 219 } else { 220 exact_tree_archive::read_blob( 221 &service_root, 222 &initial_head, 223 &artifact_path, 224 MAX_MANIFEST_BYTES, 225 ) 226 .map_err(|_| CommandError::InvalidArtifactContract)? 227 }; 228 let live_contract = read_bounded_regular( 229 &service_root.join(&artifact_path), 230 MAX_MANIFEST_BYTES, 231 CommandError::InvalidArtifactContract, 232 )?; 233 if artifact_contract != live_contract { 234 return Err(CommandError::InvalidArtifactContract); 235 } 236 let artifact_contract_sha256 = sha256(&artifact_contract); 237 validate_service_snapshot(&service_root, &initial_head, initial_index.as_deref())?; 238 239 let desired = ServiceSourceLockV4::new(ServiceSourceLockV4Parts { 240 service: &metadata.service, 241 revision: &archive.revision, 242 workspace_catalog_sha256: &archive.catalog_sha256, 243 source_archive_sha256: &archive.archive_sha256, 244 cargo_lock_sha256: &cargo_lock_sha256, 245 flake_lock_sha256: &nix.flake_lock_sha256, 246 artifact_contract_sha256: &artifact_contract_sha256, 247 contract_versions: metadata.contract_versions, 248 }) 249 .map_err(|_| CommandError::InvalidServiceMetadata)?; 250 251 let lock_path = service_root.join(LOCK_FILENAME); 252 let result = match mode { 253 CommandMode::Check => { 254 let current = 255 read_bounded_regular(&lock_path, MAX_LOCK_BYTES, CommandError::InvalidSourceLock)?; 256 let current = ServiceSourceLockV4::from_canonical_bytes(¤t) 257 .map_err(|_| CommandError::InvalidSourceLock)?; 258 if current == desired { 259 Ok(()) 260 } else { 261 Err(CommandError::StaleSourceLock) 262 } 263 } 264 CommandMode::Write | CommandMode::Prepare => { 265 atomic_write_lock(&service_root, &lock_path, desired.canonical_bytes())?; 266 let current = 267 read_bounded_regular(&lock_path, MAX_LOCK_BYTES, CommandError::WriteFailure)?; 268 let current = ServiceSourceLockV4::from_canonical_bytes(¤t) 269 .map_err(|_| CommandError::WriteFailure)?; 270 if current == desired { 271 Ok(()) 272 } else { 273 Err(CommandError::WriteFailure) 274 } 275 } 276 }; 277 result?; 278 validate_service_snapshot(&service_root, &initial_head, initial_index.as_deref()) 279 } 280 281 fn service_index(root: &Path) -> Result<String, CommandError> { 282 let bytes = 283 git_stdout(root, ["write-tree"], 128).map_err(|_| CommandError::DirtyServiceSource)?; 284 let tree = std::str::from_utf8(&bytes) 285 .map_err(|_| CommandError::DirtyServiceSource)? 286 .trim(); 287 if valid_lower_hex(tree, 40) { 288 Ok(tree.to_owned()) 289 } else { 290 Err(CommandError::DirtyServiceSource) 291 } 292 } 293 294 fn validate_service_snapshot( 295 root: &Path, 296 head: &str, 297 index: Option<&str>, 298 ) -> Result<(), CommandError> { 299 validate_service_cleanliness(root, index.is_some())?; 300 if service_head(root)? != head 301 || index.is_some_and(|expected| service_index(root).as_deref() != Ok(expected)) 302 { 303 return Err(CommandError::DirtyServiceSource); 304 } 305 Ok(()) 306 } 307 308 fn service_head(root: &Path) -> Result<String, CommandError> { 309 let bytes = git_stdout(root, ["rev-parse", "HEAD"], 128) 310 .map_err(|_| CommandError::InvalidServiceRoot)?; 311 let revision = std::str::from_utf8(&bytes) 312 .map_err(|_| CommandError::InvalidServiceRoot)? 313 .trim(); 314 if valid_lower_hex(revision, 40) { 315 Ok(revision.to_owned()) 316 } else { 317 Err(CommandError::InvalidServiceRoot) 318 } 319 } 320 321 fn validate_service_root(path: &Path) -> Result<PathBuf, CommandError> { 322 if !path.is_absolute() { 323 return Err(CommandError::InvalidServiceRoot); 324 } 325 let metadata = fs::symlink_metadata(path).map_err(|_| CommandError::InvalidServiceRoot)?; 326 if metadata.file_type().is_symlink() || !metadata.is_dir() { 327 return Err(CommandError::InvalidServiceRoot); 328 } 329 let canonical = fs::canonicalize(path).map_err(|_| CommandError::InvalidServiceRoot)?; 330 let top = git_stdout( 331 &canonical, 332 ["rev-parse", "--show-toplevel"], 333 MAX_GIT_OUTPUT_BYTES, 334 ) 335 .map_err(|_| CommandError::InvalidServiceRoot)?; 336 let top = std::str::from_utf8(&top).map_err(|_| CommandError::InvalidServiceRoot)?; 337 let top = fs::canonicalize(top.trim()).map_err(|_| CommandError::InvalidServiceRoot)?; 338 if top == canonical { 339 Ok(canonical) 340 } else { 341 Err(CommandError::InvalidServiceRoot) 342 } 343 } 344 345 fn validate_service_cleanliness(root: &Path, prepared: bool) -> Result<(), CommandError> { 346 git_status( 347 root, 348 [ 349 "diff", 350 "--quiet", 351 "--", 352 ".", 353 ":(exclude)radroots.service.source_lock.v4.toml", 354 ], 355 ) 356 .map_err(|_| CommandError::DirtyServiceSource)?; 357 if !prepared { 358 git_status( 359 root, 360 [ 361 "diff", 362 "--cached", 363 "--quiet", 364 "--", 365 ".", 366 ":(exclude)radroots.service.source_lock.v4.toml", 367 ], 368 ) 369 .map_err(|_| CommandError::DirtyServiceSource)?; 370 } 371 let untracked = git_stdout( 372 root, 373 ["ls-files", "--others", "--exclude-standard", "-z"], 374 MAX_GIT_OUTPUT_BYTES, 375 ) 376 .map_err(|_| CommandError::DirtyServiceSource)?; 377 let mut paths = untracked 378 .split(|byte| *byte == 0) 379 .filter(|path| !path.is_empty()); 380 if paths.all(|path| path == LOCK_FILENAME.as_bytes()) { 381 Ok(()) 382 } else { 383 Err(CommandError::DirtyServiceSource) 384 } 385 } 386 387 fn parse_service_metadata(root: &toml::Value) -> Result<ServiceMetadata, CommandError> { 388 let table = root 389 .get("workspace") 390 .and_then(|value| value.get("metadata")) 391 .and_then(|value| value.get("radroots")) 392 .and_then(|value| value.get("service_source_lock")) 393 .and_then(toml::Value::as_table) 394 .ok_or(CommandError::InvalidServiceMetadata)?; 395 let expected = BTreeSet::from([ 396 "admin_contract_version", 397 "config_contract_version", 398 "host_feature_profile", 399 "nix_material", 400 "provider_contract_version", 401 "service", 402 "state_contract_version", 403 "status_contract_version", 404 ]); 405 if table.keys().map(String::as_str).collect::<BTreeSet<_>>() != expected { 406 return Err(CommandError::InvalidServiceMetadata); 407 } 408 let text = |key: &str| { 409 table 410 .get(key) 411 .and_then(toml::Value::as_str) 412 .ok_or(CommandError::InvalidServiceMetadata) 413 }; 414 let version = |key: &str| { 415 table 416 .get(key) 417 .and_then(toml::Value::as_integer) 418 .and_then(|value| u32::try_from(value).ok()) 419 .filter(|value| *value != 0) 420 .ok_or(CommandError::InvalidServiceMetadata) 421 }; 422 if text("host_feature_profile")? != HOST_FEATURE_PROFILE { 423 return Err(CommandError::InvalidServiceMetadata); 424 } 425 if text("nix_material")? != "bound" || !matches!(text("service")?, "myc" | "rhi") { 426 return Err(CommandError::InvalidServiceMetadata); 427 } 428 Ok(ServiceMetadata { 429 service: text("service")?.to_owned(), 430 contract_versions: ContractVersions::new( 431 version("config_contract_version")?, 432 version("state_contract_version")?, 433 version("admin_contract_version")?, 434 version("status_contract_version")?, 435 version("provider_contract_version")?, 436 ), 437 }) 438 } 439 440 fn validate_cargo_manifests( 441 root: &Path, 442 lib_packages: Option<&BTreeSet<String>>, 443 ) -> Result<String, CommandError> { 444 let mut manifests = Vec::new(); 445 let mut entries = 0_usize; 446 let walker = WalkDir::new(root) 447 .follow_links(false) 448 .into_iter() 449 .filter_entry(|entry| { 450 entry.file_name() != OsStr::new(".git") && !is_build_output_directory(entry.file_name()) 451 }); 452 for entry in walker { 453 entries = entries 454 .checked_add(1) 455 .ok_or(CommandError::InvalidCargoManifest)?; 456 if entries > MAX_TREE_ENTRIES { 457 return Err(CommandError::InvalidCargoManifest); 458 } 459 let entry = entry.map_err(|_| CommandError::InvalidCargoManifest)?; 460 if entry.file_name() == OsStr::new(CARGO_MANIFEST) { 461 if entry.file_type().is_symlink() || !entry.file_type().is_file() { 462 return Err(CommandError::InvalidCargoManifest); 463 } 464 manifests.push(entry.into_path()); 465 if manifests.len() > MAX_MANIFESTS { 466 return Err(CommandError::InvalidCargoManifest); 467 } 468 } 469 } 470 manifests.sort(); 471 if manifests.is_empty() { 472 return Err(CommandError::InvalidCargoManifest); 473 } 474 let mut state = ManifestState::default(); 475 for manifest in manifests { 476 let bytes = read_bounded_regular( 477 &manifest, 478 MAX_MANIFEST_BYTES, 479 CommandError::InvalidCargoManifest, 480 )?; 481 let value = parse_toml(&bytes, CommandError::InvalidCargoManifest)?; 482 validate_manifest_node(&value, None, false, false, lib_packages, &mut state)?; 483 } 484 if state.dependencies == 0 || !state.host_dependency { 485 return Err(CommandError::InvalidCargoManifest); 486 } 487 state.revision.ok_or(CommandError::InvalidCargoManifest) 488 } 489 490 #[derive(Default)] 491 struct ManifestState { 492 revision: Option<String>, 493 dependencies: usize, 494 host_dependency: bool, 495 } 496 497 fn validate_manifest_node( 498 value: &toml::Value, 499 key: Option<&str>, 500 in_patch: bool, 501 in_dependencies: bool, 502 lib_packages: Option<&BTreeSet<String>>, 503 state: &mut ManifestState, 504 ) -> Result<(), CommandError> { 505 match value { 506 toml::Value::Table(table) => { 507 let git = table.get("git").and_then(toml::Value::as_str); 508 let package = table.get("package").and_then(toml::Value::as_str).or(key); 509 let known_lib_dependency = (in_dependencies || in_patch) 510 && package.is_some_and(|package| { 511 lib_packages.map_or(package == HOST_PACKAGE, |packages| { 512 packages.contains(package) 513 }) 514 }); 515 let canonical_lib_dependency = 516 (in_dependencies || in_patch) && git.is_some_and(|git| git == LIB_REPOSITORY); 517 if known_lib_dependency || canonical_lib_dependency { 518 let git = git.ok_or(CommandError::InvalidCargoManifest)?; 519 if in_patch 520 || git != LIB_REPOSITORY 521 || table.get("version").and_then(toml::Value::as_str) 522 != Some(LIB_VERSION_REQUIREMENT) 523 || table.contains_key("branch") 524 || table.contains_key("tag") 525 || table.contains_key("path") 526 { 527 return Err(CommandError::InvalidCargoManifest); 528 } 529 let revision = table 530 .get("rev") 531 .and_then(toml::Value::as_str) 532 .filter(|value| valid_lower_hex(value, 40)) 533 .ok_or(CommandError::InvalidCargoManifest)?; 534 match &state.revision { 535 Some(expected) if expected != revision => { 536 return Err(CommandError::InvalidCargoManifest); 537 } 538 None => state.revision = Some(revision.to_owned()), 539 _ => {} 540 } 541 state.dependencies += 1; 542 state.host_dependency |= key == Some(HOST_PACKAGE) 543 || table.get("package").and_then(toml::Value::as_str) == Some(HOST_PACKAGE); 544 } 545 for (child_key, child) in table { 546 if (known_lib_dependency || canonical_lib_dependency) && child_key == "git" { 547 continue; 548 } 549 let child_dependency_scope = in_dependencies 550 || matches!( 551 child_key.as_str(), 552 "dependencies" | "dev-dependencies" | "build-dependencies" 553 ); 554 validate_manifest_node( 555 child, 556 Some(child_key), 557 in_patch || child_key == "patch", 558 child_dependency_scope, 559 lib_packages, 560 state, 561 )?; 562 } 563 } 564 toml::Value::Array(values) => { 565 for child in values { 566 validate_manifest_node(child, key, in_patch, in_dependencies, lib_packages, state)?; 567 } 568 } 569 toml::Value::String(_) 570 if in_dependencies 571 && key.is_some_and(|key| { 572 lib_packages.map_or(key == HOST_PACKAGE, |packages| packages.contains(key)) 573 }) => 574 { 575 return Err(CommandError::InvalidCargoManifest); 576 } 577 _ => {} 578 } 579 Ok(()) 580 } 581 582 fn validate_cargo_lock( 583 bytes: &[u8], 584 revision: &str, 585 lib_packages: &BTreeSet<String>, 586 ) -> Result<(), CommandError> { 587 let text = std::str::from_utf8(bytes).map_err(|_| CommandError::InvalidCargoLock)?; 588 let document = 589 toml::from_str::<CargoLockDocument>(text).map_err(|_| CommandError::InvalidCargoLock)?; 590 let expected = format!("git+{LIB_REPOSITORY}?rev={revision}#{revision}"); 591 let mut count = 0_usize; 592 let mut host = false; 593 for package in document.package { 594 if lib_packages.contains(&package.name) { 595 let source = package.source.ok_or(CommandError::InvalidCargoLock)?; 596 if source != expected || package.version != "0.1.0-alpha" { 597 return Err(CommandError::InvalidCargoLock); 598 } 599 count += 1; 600 host |= package.name == HOST_PACKAGE; 601 } 602 } 603 if count != 0 && host { 604 Ok(()) 605 } else { 606 Err(CommandError::InvalidCargoLock) 607 } 608 } 609 610 fn read_nix_material(root: &Path) -> Result<NixMaterialEvidence, CommandError> { 611 let expression = read_bounded_regular( 612 &root.join(FLAKE_NIX), 613 MAX_FLAKE_NIX_BYTES, 614 CommandError::InvalidNixMaterial, 615 )?; 616 let lock = read_bounded_regular( 617 &root.join(FLAKE_LOCK), 618 MAX_FLAKE_LOCK_BYTES, 619 CommandError::InvalidFlakeLock, 620 )?; 621 validate_bound_nix_lock(&lock).map_err(|_| CommandError::InvalidFlakeLock)?; 622 let evidence = validate_bound_nix_material(&expression, &lock) 623 .map_err(|_| CommandError::InvalidNixMaterial)?; 624 Ok(NixMaterialEvidence { 625 lib_revision: evidence.revision, 626 flake_lock_sha256: evidence.lock_sha256, 627 }) 628 } 629 630 #[cfg(test)] 631 fn validate_flake_lock(bytes: &[u8]) -> Result<String, CommandError> { 632 validate_bound_nix_lock(bytes).map_err(|_| CommandError::InvalidFlakeLock) 633 } 634 635 fn validate_toolchain(root: &Path) -> Result<(), CommandError> { 636 let bytes = read_bounded_regular( 637 &root.join(RUST_TOOLCHAIN), 638 MAX_TOOLCHAIN_BYTES, 639 CommandError::InvalidToolchain, 640 )?; 641 validate_toolchain_bytes(&bytes).map_err(|_| CommandError::InvalidToolchain) 642 } 643 644 fn validate_archive(path: &Path, revision: &str) -> Result<ArchiveEvidence, CommandError> { 645 if !path.is_absolute() { 646 return Err(CommandError::InvalidSourceArchive); 647 } 648 let metadata = fs::symlink_metadata(path).map_err(|_| CommandError::InvalidSourceArchive)?; 649 if metadata.file_type().is_symlink() 650 || !metadata.is_file() 651 || metadata.len() == 0 652 || metadata.len() > MAX_ARCHIVE_BYTES 653 { 654 return Err(CommandError::InvalidSourceArchive); 655 } 656 let mut source = fs::File::open(path).map_err(|_| CommandError::InvalidSourceArchive)?; 657 let before = source 658 .metadata() 659 .map_err(|_| CommandError::InvalidSourceArchive)?; 660 let mut stable = NamedTempFile::new().map_err(|_| CommandError::InvalidSourceArchive)?; 661 let mut total = 0_u64; 662 let mut buffer = [0_u8; 65_536]; 663 loop { 664 let read = source 665 .read(&mut buffer) 666 .map_err(|_| CommandError::InvalidSourceArchive)?; 667 if read == 0 { 668 break; 669 } 670 total = total 671 .checked_add(u64::try_from(read).map_err(|_| CommandError::InvalidSourceArchive)?) 672 .filter(|total| *total <= MAX_ARCHIVE_BYTES) 673 .ok_or(CommandError::InvalidSourceArchive)?; 674 stable 675 .write_all(&buffer[..read]) 676 .map_err(|_| CommandError::InvalidSourceArchive)?; 677 } 678 let after = source 679 .metadata() 680 .map_err(|_| CommandError::InvalidSourceArchive)?; 681 if total == 0 || before.len() != total || after.len() != total { 682 return Err(CommandError::InvalidSourceArchive); 683 } 684 stable 685 .flush() 686 .and_then(|()| stable.as_file().sync_all()) 687 .map_err(|_| CommandError::InvalidSourceArchive)?; 688 stable 689 .as_file_mut() 690 .seek(SeekFrom::Start(0)) 691 .map_err(|_| CommandError::InvalidSourceArchive)?; 692 693 let verification = TempDir::new().map_err(|_| CommandError::InvalidSourceArchive)?; 694 git_status(verification.path(), ["init", "--bare", "--quiet"]) 695 .map_err(|_| CommandError::InvalidSourceArchive)?; 696 let status = Command::new("git") 697 .args(["bundle", "verify"]) 698 .arg(stable.path()) 699 .current_dir(verification.path()) 700 .stdin(Stdio::null()) 701 .stdout(Stdio::null()) 702 .stderr(Stdio::null()) 703 .status() 704 .map_err(|_| CommandError::InvalidSourceArchive)?; 705 if !status.success() { 706 return Err(CommandError::InvalidSourceArchive); 707 } 708 let heads = command_stdout( 709 Command::new("git") 710 .args(["bundle", "list-heads"]) 711 .arg(stable.path()), 712 MAX_GIT_OUTPUT_BYTES, 713 ) 714 .map_err(|_| CommandError::InvalidSourceArchive)?; 715 let expected_head = format!("{revision} refs/heads/archive\n"); 716 if heads != expected_head.as_bytes() { 717 return Err(CommandError::InvalidSourceArchive); 718 } 719 let fetch = Command::new("git") 720 .args(["fetch", "--quiet", "--no-tags"]) 721 .arg(stable.path()) 722 .arg(format!("{revision}:refs/heads/archive")) 723 .current_dir(verification.path()) 724 .stdin(Stdio::null()) 725 .stdout(Stdio::null()) 726 .stderr(Stdio::null()) 727 .status() 728 .map_err(|_| CommandError::InvalidSourceArchive)?; 729 if !fetch.success() { 730 return Err(CommandError::InvalidSourceArchive); 731 } 732 let catalog_spec = format!("{revision}:{CATALOG_RELATIVE}"); 733 let catalog = git_stdout( 734 verification.path(), 735 ["show", catalog_spec.as_str()], 736 MAX_CATALOG_BYTES, 737 ) 738 .map_err(|_| CommandError::InvalidSourceArchive)?; 739 if catalog.is_empty() { 740 return Err(CommandError::InvalidSourceArchive); 741 } 742 let package_names = catalog_package_names(&catalog)?; 743 let manifest = exact_tree_archive::read_blob( 744 &fs::canonicalize(verification.path()).map_err(|_| CommandError::InvalidSourceArchive)?, 745 revision, 746 CARGO_MANIFEST, 747 MAX_MANIFEST_BYTES, 748 ) 749 .map_err(|_| CommandError::InvalidSourceArchive)?; 750 let verification_root = 751 fs::canonicalize(verification.path()).map_err(|_| CommandError::InvalidSourceArchive)?; 752 let toolchain = exact_tree_archive::read_blob( 753 &verification_root, 754 revision, 755 RUST_TOOLCHAIN, 756 MAX_TOOLCHAIN_BYTES, 757 ) 758 .map_err(|_| CommandError::InvalidSourceArchive)?; 759 validate_lib_compiler_inputs(&manifest, &toolchain, &catalog) 760 .map_err(|_| CommandError::InvalidSourceArchive)?; 761 // The bundle is transfer evidence. The lock always binds the canonical tree. 762 let mtime = exact_tree_archive::commit_timestamp(&verification_root, revision) 763 .map_err(|_| CommandError::InvalidSourceArchive)?; 764 let tree = exact_tree_archive::create( 765 &verification_root, 766 revision, 767 &verification_root.join("source-tree.tar"), 768 mtime, 769 ) 770 .map_err(|_| CommandError::InvalidSourceArchive)?; 771 Ok(ArchiveEvidence { 772 revision: revision.to_owned(), 773 archive_sha256: tree.sha256, 774 catalog_sha256: sha256(&catalog), 775 package_names, 776 }) 777 } 778 779 fn catalog_package_names(bytes: &[u8]) -> Result<BTreeSet<String>, CommandError> { 780 let value = parse_toml(bytes, CommandError::InvalidSourceArchive)?; 781 if value.get("schema").and_then(toml::Value::as_str) != Some("radroots.workspace.catalog.v2") 782 || value.get("architecture").and_then(toml::Value::as_str) 783 != Some("radroots.crates.release.v2") 784 || value.get("version").and_then(toml::Value::as_str) != Some("0.1.0-alpha") 785 { 786 return Err(CommandError::InvalidSourceArchive); 787 } 788 let packages = value 789 .get("package") 790 .and_then(toml::Value::as_array) 791 .ok_or(CommandError::InvalidSourceArchive)?; 792 let expected_count = value 793 .get("package_count") 794 .and_then(toml::Value::as_integer) 795 .and_then(|count| usize::try_from(count).ok()) 796 .ok_or(CommandError::InvalidSourceArchive)?; 797 if packages.is_empty() || packages.len() != expected_count || packages.len() > MAX_MANIFESTS { 798 return Err(CommandError::InvalidSourceArchive); 799 } 800 let mut names = BTreeSet::new(); 801 for package in packages { 802 let name = package 803 .get("name") 804 .and_then(toml::Value::as_str) 805 .ok_or(CommandError::InvalidSourceArchive)?; 806 if !names.insert(name.to_owned()) { 807 return Err(CommandError::InvalidSourceArchive); 808 } 809 } 810 if names.contains(HOST_PACKAGE) { 811 Ok(names) 812 } else { 813 Err(CommandError::InvalidSourceArchive) 814 } 815 } 816 817 fn atomic_write_lock(root: &Path, path: &Path, bytes: &[u8]) -> Result<(), CommandError> { 818 if let Ok(metadata) = fs::symlink_metadata(path) 819 && (metadata.file_type().is_symlink() || !metadata.is_file()) 820 { 821 return Err(CommandError::WriteFailure); 822 } 823 let mut temporary = NamedTempFile::new_in(root).map_err(|_| CommandError::WriteFailure)?; 824 temporary 825 .write_all(bytes) 826 .and_then(|()| temporary.as_file().sync_all()) 827 .map_err(|_| CommandError::WriteFailure)?; 828 temporary 829 .persist(path) 830 .map_err(|_| CommandError::WriteFailure)?; 831 fs::File::open(root) 832 .and_then(|directory| directory.sync_all()) 833 .map_err(|_| CommandError::WriteFailure) 834 } 835 836 fn read_bounded_regular( 837 path: &Path, 838 maximum: usize, 839 error: CommandError, 840 ) -> Result<Vec<u8>, CommandError> { 841 let metadata = fs::symlink_metadata(path).map_err(|_| error)?; 842 if metadata.file_type().is_symlink() || !metadata.is_file() || metadata.len() > maximum as u64 { 843 return Err(error); 844 } 845 let file = fs::File::open(path).map_err(|_| error)?; 846 let mut bytes = Vec::with_capacity(usize::try_from(metadata.len()).map_err(|_| error)?); 847 file.take(maximum as u64 + 1) 848 .read_to_end(&mut bytes) 849 .map_err(|_| error)?; 850 if bytes.len() > maximum { 851 Err(error) 852 } else { 853 Ok(bytes) 854 } 855 } 856 857 fn parse_toml(bytes: &[u8], error: CommandError) -> Result<toml::Value, CommandError> { 858 let text = std::str::from_utf8(bytes).map_err(|_| error)?; 859 toml::from_str(text).map_err(|_| error) 860 } 861 862 fn sha256(bytes: &[u8]) -> String { 863 hex::encode(Sha256::digest(bytes)) 864 } 865 866 fn valid_lower_hex(value: &str, length: usize) -> bool { 867 value.len() == length 868 && value 869 .bytes() 870 .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte)) 871 } 872 873 #[cfg(test)] 874 fn valid_nix_sha256(value: &str) -> bool { 875 let Some(encoded) = value.strip_prefix("sha256-") else { 876 return false; 877 }; 878 let bytes = encoded.as_bytes(); 879 bytes.len() == 44 880 && bytes[43] == b'=' 881 && bytes[..43] 882 .iter() 883 .copied() 884 .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'+' | b'/')) 885 } 886 887 fn git_status<const N: usize>(root: &Path, args: [&str; N]) -> Result<(), ()> { 888 let status = Command::new("git") 889 .args(args) 890 .current_dir(root) 891 .stdin(Stdio::null()) 892 .stdout(Stdio::null()) 893 .stderr(Stdio::null()) 894 .status() 895 .map_err(|_| ())?; 896 if status.success() { Ok(()) } else { Err(()) } 897 } 898 899 fn git_stdout<const N: usize>(root: &Path, args: [&str; N], maximum: usize) -> Result<Vec<u8>, ()> { 900 let mut command = Command::new("git"); 901 command.args(args).current_dir(root); 902 command_stdout(&mut command, maximum) 903 } 904 905 fn command_stdout(command: &mut Command, maximum: usize) -> Result<Vec<u8>, ()> { 906 let mut child = command 907 .stdin(Stdio::null()) 908 .stdout(Stdio::piped()) 909 .stderr(Stdio::null()) 910 .spawn() 911 .map_err(|_| ())?; 912 let mut stdout = child.stdout.take().ok_or(())?; 913 let mut bytes = Vec::new(); 914 if stdout 915 .by_ref() 916 .take(maximum as u64 + 1) 917 .read_to_end(&mut bytes) 918 .is_err() 919 { 920 let _ = child.kill(); 921 let _ = child.wait(); 922 return Err(()); 923 } 924 if bytes.len() > maximum { 925 let _ = child.kill(); 926 let _ = child.wait(); 927 return Err(()); 928 } 929 let status = child.wait().map_err(|_| ())?; 930 if status.success() { Ok(bytes) } else { Err(()) } 931 } 932 933 #[cfg(test)] 934 mod tests { 935 use std::{ 936 error::Error as _, 937 sync::atomic::{AtomicBool, Ordering}, 938 }; 939 940 use super::*; 941 942 struct Reachability { 943 reachable: AtomicBool, 944 } 945 946 impl RevisionReachability for Reachability { 947 fn verify(&self, _revision: &str) -> Result<(), CommandError> { 948 if self.reachable.load(Ordering::SeqCst) { 949 Ok(()) 950 } else { 951 Err(CommandError::UnreachableRevision) 952 } 953 } 954 } 955 956 struct CommitOnVerify { 957 service: PathBuf, 958 } 959 960 struct IndexOnVerify { 961 service: PathBuf, 962 } 963 964 impl RevisionReachability for IndexOnVerify { 965 fn verify(&self, _revision: &str) -> Result<(), CommandError> { 966 fs::write(self.service.join("concurrent"), b"staged").expect("concurrent file"); 967 git(&self.service, &["add", "concurrent"]); 968 Ok(()) 969 } 970 } 971 972 impl RevisionReachability for CommitOnVerify { 973 fn verify(&self, _revision: &str) -> Result<(), CommandError> { 974 fs::write(self.service.join("concurrent"), b"changed").expect("concurrent file"); 975 git(&self.service, &["add", "."]); 976 git( 977 &self.service, 978 &["commit", "--quiet", "-m", "concurrent commit"], 979 ); 980 Ok(()) 981 } 982 } 983 984 struct Fixture { 985 root: TempDir, 986 service: PathBuf, 987 archive: PathBuf, 988 revision: String, 989 } 990 991 impl Fixture { 992 fn new() -> Self { 993 let root = TempDir::new().expect("temp root"); 994 let lib = root.path().join("lib"); 995 fs::create_dir(&lib).expect("lib root"); 996 git(&lib, &["init", "--quiet"]); 997 git(&lib, &["config", "user.email", "fixture@example.invalid"]); 998 git(&lib, &["config", "user.name", "fixture"]); 999 let catalog = lib.join(CATALOG_RELATIVE); 1000 fs::create_dir_all(catalog.parent().expect("catalog parent")).expect("catalog parent"); 1001 fs::write( 1002 &catalog, 1003 br#"schema_version = 2 1004 schema = "radroots.workspace.catalog.v2" 1005 architecture = "radroots.crates.release.v2" 1006 version = "0.1.0-alpha" 1007 rust_version = "1.99.0" 1008 edition = "2024" 1009 resolver = "3" 1010 package_count = 2 1011 1012 [[package]] 1013 name = "radroots_core" 1014 1015 [[package]] 1016 name = "radroots_service_host" 1017 "#, 1018 ) 1019 .expect("catalog"); 1020 fs::write(lib.join(CARGO_MANIFEST), 1021 "[workspace]\nresolver = \"3\"\n[workspace.package]\nversion = \"0.1.0-alpha\"\nrust-version = \"1.99.0\"\nedition = \"2024\"\n" 1022 ).expect("Lib manifest"); 1023 fs::write( 1024 lib.join(RUST_TOOLCHAIN), 1025 "[toolchain]\nchannel = \"1.99.0\"\n", 1026 ) 1027 .expect("Lib toolchain"); 1028 git(&lib, &["add", "."]); 1029 git(&lib, &["commit", "--quiet", "-m", "fixture"]); 1030 git(&lib, &["branch", "-M", "archive"]); 1031 let revision = 1032 String::from_utf8(git_stdout(&lib, ["rev-parse", "HEAD"], 128).expect("revision")) 1033 .expect("UTF-8") 1034 .trim() 1035 .to_owned(); 1036 let archive = root.path().join("lib.bundle"); 1037 let status = Command::new("git") 1038 .args(["bundle", "create"]) 1039 .arg(&archive) 1040 .arg("refs/heads/archive") 1041 .current_dir(&lib) 1042 .status() 1043 .expect("bundle"); 1044 assert!(status.success()); 1045 1046 let service = root.path().join("service"); 1047 fs::create_dir(&service).expect("service root"); 1048 fs::write( 1049 service.join(CARGO_MANIFEST), 1050 format!( 1051 r#"[workspace] 1052 resolver = "3" 1053 1054 [workspace.metadata.radroots.service_source_lock] 1055 service = "myc" 1056 host_feature_profile = "service-host" 1057 nix_material = "bound" 1058 config_contract_version = 1 1059 state_contract_version = 2 1060 admin_contract_version = 3 1061 status_contract_version = 4 1062 provider_contract_version = 5 1063 1064 [workspace.dependencies] 1065 radroots_service_host = {{ git = "{LIB_REPOSITORY}", rev = "{revision}", version = "=0.1.0-alpha" }} 1066 "#, 1067 ), 1068 ) 1069 .expect("manifest"); 1070 fs::write( 1071 service.join(CARGO_LOCK), 1072 format!( 1073 "version = 4\n\n[[package]]\nname = \"radroots_service_host\"\nversion = \"0.1.0-alpha\"\nsource = \"git+{LIB_REPOSITORY}?rev={revision}#{revision}\"\n" 1074 ), 1075 ) 1076 .expect("Cargo.lock"); 1077 fs::write( 1078 service.join(FLAKE_NIX), 1079 format!( 1080 "{{\n inputs.lib = {{\n url = \"github:radrootslabs/lib/{revision}\";\n flake = false;\n }};\n outputs = {{ ... }}: {{ }};\n}}\n" 1081 ), 1082 ) 1083 .expect("flake.nix"); 1084 fs::write( 1085 service.join(FLAKE_LOCK), 1086 format!( 1087 r#"{{"nodes":{{"root":{{"inputs":{{"lib":"lib"}}}},"lib":{{"locked":{{"lastModified":1,"narHash":"sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=","owner":"radrootslabs","repo":"lib","rev":"{revision}","type":"github"}},"original":{{"owner":"radrootslabs","repo":"lib","rev":"{revision}","type":"github"}}}}}},"root":"root","version":7}} 1088 "#, 1089 ), 1090 ) 1091 .expect("flake.lock"); 1092 fs::write( 1093 service.join(RUST_TOOLCHAIN), 1094 "[toolchain]\nchannel = \"1.99.0\"\ncomponents = [\"clippy\", \"rustfmt\"]\n", 1095 ) 1096 .expect("toolchain"); 1097 fs::create_dir_all(service.join("contracts/release")).expect("artifact parent"); 1098 fs::write( 1099 service.join("contracts/release/myc-artifact-contract.v4.json"), 1100 b"{}\n", 1101 ) 1102 .expect("artifact contract"); 1103 git(&service, &["init", "--quiet"]); 1104 git( 1105 &service, 1106 &["config", "user.email", "fixture@example.invalid"], 1107 ); 1108 git(&service, &["config", "user.name", "fixture"]); 1109 git(&service, &["add", "."]); 1110 git(&service, &["commit", "--quiet", "-m", "fixture"]); 1111 Self { 1112 root, 1113 service, 1114 archive, 1115 revision, 1116 } 1117 } 1118 1119 fn reachable(&self) -> Reachability { 1120 Reachability { 1121 reachable: AtomicBool::new(true), 1122 } 1123 } 1124 } 1125 1126 fn git(root: &Path, args: &[&str]) { 1127 let status = Command::new("git") 1128 .args(args) 1129 .current_dir(root) 1130 .status() 1131 .expect("git"); 1132 assert!(status.success(), "git {args:?}"); 1133 } 1134 1135 #[test] 1136 fn update_and_check_bind_complete_local_evidence() { 1137 let fixture = Fixture::new(); 1138 let reachability = fixture.reachable(); 1139 run_with( 1140 CommandMode::Write, 1141 &fixture.service, 1142 &fixture.archive, 1143 &reachability, 1144 ) 1145 .expect("write lock"); 1146 run_with( 1147 CommandMode::Check, 1148 &fixture.service, 1149 &fixture.archive, 1150 &reachability, 1151 ) 1152 .expect("check lock"); 1153 1154 let bytes = fs::read(fixture.service.join(LOCK_FILENAME)).expect("lock"); 1155 let text = std::str::from_utf8(&bytes).expect("UTF-8"); 1156 assert!(text.contains("service = \"myc\"")); 1157 assert!(text.contains(&format!("revision = \"{}\"", fixture.revision))); 1158 assert!(text.contains("material = \"bound\"")); 1159 assert!(text.contains(&format!("lib_revision = \"{}\"", fixture.revision))); 1160 assert!(text.contains("config = 1\nstate = 2\nadmin = 3\nstatus = 4\nprovider = 5")); 1161 assert!(fixture.root.path().exists()); 1162 let lock = ServiceSourceLockV4::from_canonical_bytes(&bytes).expect("V4 lock"); 1163 let lib = fs::canonicalize(fixture.root.path().join("lib")).expect("Lib root"); 1164 let tree = exact_tree_archive::create( 1165 &lib, 1166 &fixture.revision, 1167 &lib.parent() 1168 .expect("fixture parent") 1169 .join("expected-source.tar"), 1170 exact_tree_archive::commit_timestamp(&lib, &fixture.revision).expect("commit time"), 1171 ) 1172 .expect("exact source tree"); 1173 assert_eq!(lock.source_archive_sha256(), tree.sha256); 1174 assert_ne!( 1175 lock.source_archive_sha256(), 1176 sha256(&fs::read(&fixture.archive).expect("bundle")) 1177 ); 1178 crate::service_release_artifacts::validate_writer_fixture(&fixture.service, &lock) 1179 .expect("artifact consumer admits actual writer output"); 1180 } 1181 1182 #[test] 1183 fn check_rejects_stale_lock_and_update_repairs_it() { 1184 let fixture = Fixture::new(); 1185 let reachability = fixture.reachable(); 1186 run_with( 1187 CommandMode::Write, 1188 &fixture.service, 1189 &fixture.archive, 1190 &reachability, 1191 ) 1192 .expect("write lock"); 1193 let lock = fixture.service.join(LOCK_FILENAME); 1194 let stale = 1195 fs::read_to_string(&lock) 1196 .expect("read lock") 1197 .replacen("config = 1", "config = 9", 1); 1198 fs::write(&lock, stale).expect("stale lock"); 1199 assert_eq!( 1200 run_with( 1201 CommandMode::Check, 1202 &fixture.service, 1203 &fixture.archive, 1204 &reachability, 1205 ), 1206 Err(CommandError::StaleSourceLock) 1207 ); 1208 run_with( 1209 CommandMode::Write, 1210 &fixture.service, 1211 &fixture.archive, 1212 &reachability, 1213 ) 1214 .expect("repair lock"); 1215 } 1216 1217 #[test] 1218 fn dirty_source_and_unreachable_revision_fail_closed() { 1219 let fixture = Fixture::new(); 1220 fs::write(fixture.service.join("untracked-secret"), b"sensitive").expect("dirty file"); 1221 assert_eq!( 1222 run_with( 1223 CommandMode::Write, 1224 &fixture.service, 1225 &fixture.archive, 1226 &fixture.reachable(), 1227 ), 1228 Err(CommandError::DirtyServiceSource) 1229 ); 1230 fs::remove_file(fixture.service.join("untracked-secret")).expect("remove dirty file"); 1231 let unreachable = Reachability { 1232 reachable: AtomicBool::new(false), 1233 }; 1234 assert_eq!( 1235 run_with( 1236 CommandMode::Write, 1237 &fixture.service, 1238 &fixture.archive, 1239 &unreachable, 1240 ), 1241 Err(CommandError::UnreachableRevision) 1242 ); 1243 assert!(!fixture.service.join(LOCK_FILENAME).exists()); 1244 1245 let fixture = Fixture::new(); 1246 let commit_on_verify = CommitOnVerify { 1247 service: fixture.service.clone(), 1248 }; 1249 assert_eq!( 1250 run_with( 1251 CommandMode::Write, 1252 &fixture.service, 1253 &fixture.archive, 1254 &commit_on_verify, 1255 ), 1256 Err(CommandError::DirtyServiceSource) 1257 ); 1258 assert!(!fixture.service.join(LOCK_FILENAME).exists()); 1259 } 1260 1261 #[test] 1262 fn prepared_candidate_binds_index_and_requires_committed_checking() { 1263 let fixture = Fixture::new(); 1264 let path = "contracts/release/myc-artifact-contract.v4.json"; 1265 let contract = b"{\"candidate\":true}\n"; 1266 fs::write(fixture.service.join(path), contract).expect("candidate contract"); 1267 git(&fixture.service, &["add", path]); 1268 assert_eq!( 1269 run_with( 1270 CommandMode::Write, 1271 &fixture.service, 1272 &fixture.archive, 1273 &fixture.reachable() 1274 ), 1275 Err(CommandError::DirtyServiceSource) 1276 ); 1277 run_with( 1278 CommandMode::Prepare, 1279 &fixture.service, 1280 &fixture.archive, 1281 &fixture.reachable(), 1282 ) 1283 .expect("prepare staged candidate"); 1284 let bytes = fs::read(fixture.service.join(LOCK_FILENAME)).expect("prepared lock"); 1285 let lock = ServiceSourceLockV4::from_canonical_bytes(&bytes).expect("canonical lock"); 1286 assert_eq!(lock.artifact_contract_sha256(), sha256(contract)); 1287 assert_eq!( 1288 run_with( 1289 CommandMode::Check, 1290 &fixture.service, 1291 &fixture.archive, 1292 &fixture.reachable() 1293 ), 1294 Err(CommandError::DirtyServiceSource) 1295 ); 1296 git(&fixture.service, &["add", LOCK_FILENAME]); 1297 git( 1298 &fixture.service, 1299 &["commit", "--quiet", "-m", "verified candidate"], 1300 ); 1301 run_with( 1302 CommandMode::Check, 1303 &fixture.service, 1304 &fixture.archive, 1305 &fixture.reachable(), 1306 ) 1307 .expect("check complete committed candidate"); 1308 } 1309 1310 #[test] 1311 fn preparation_refuses_unstaged_untracked_and_changed_index_inputs() { 1312 for case in ["unstaged", "untracked", "index", "head"] { 1313 let fixture = Fixture::new(); 1314 if case == "unstaged" { 1315 fs::write(fixture.service.join(CARGO_MANIFEST), b"changed").expect("unstaged"); 1316 } else if case == "untracked" { 1317 fs::write(fixture.service.join("unexpected"), b"changed").expect("untracked"); 1318 } 1319 let index = IndexOnVerify { 1320 service: fixture.service.clone(), 1321 }; 1322 let head = CommitOnVerify { 1323 service: fixture.service.clone(), 1324 }; 1325 let normal = fixture.reachable(); 1326 let remote: &dyn RevisionReachability = match case { 1327 "index" => &index, 1328 "head" => &head, 1329 _ => &normal, 1330 }; 1331 assert_eq!( 1332 run_with( 1333 CommandMode::Prepare, 1334 &fixture.service, 1335 &fixture.archive, 1336 remote 1337 ), 1338 Err(CommandError::DirtyServiceSource), 1339 "{case}" 1340 ); 1341 assert!(!fixture.service.join(LOCK_FILENAME).exists(), "{case}"); 1342 } 1343 } 1344 1345 #[test] 1346 fn cargo_flake_toolchain_and_archive_drift_are_distinct() { 1347 let cases = [ 1348 ( 1349 CARGO_MANIFEST, 1350 "radroots_service_host", 1351 "other", 1352 CommandError::InvalidCargoManifest, 1353 ), 1354 ( 1355 CARGO_LOCK, 1356 "radroots_service_host", 1357 "other", 1358 CommandError::InvalidCargoLock, 1359 ), 1360 ( 1361 FLAKE_NIX, 1362 "radrootslabs/lib", 1363 "example.invalid/lib", 1364 CommandError::InvalidNixMaterial, 1365 ), 1366 ( 1367 FLAKE_NIX, 1368 "inputs.lib = {", 1369 "other = {", 1370 CommandError::InvalidNixMaterial, 1371 ), 1372 ( 1373 FLAKE_LOCK, 1374 "radrootslabs", 1375 "other", 1376 CommandError::InvalidFlakeLock, 1377 ), 1378 ( 1379 RUST_TOOLCHAIN, 1380 "1.99.0", 1381 "1.97.0", 1382 CommandError::InvalidToolchain, 1383 ), 1384 ]; 1385 for (path, from, to, expected) in cases { 1386 let fixture = Fixture::new(); 1387 let path = fixture.service.join(path); 1388 let mutated = fs::read_to_string(&path) 1389 .expect("read fixture") 1390 .replacen(from, to, 1); 1391 fs::write(&path, mutated).expect("mutate fixture"); 1392 git(&fixture.service, &["add", "."]); 1393 git(&fixture.service, &["commit", "--quiet", "-m", "mutate"]); 1394 assert_eq!( 1395 run_with( 1396 CommandMode::Write, 1397 &fixture.service, 1398 &fixture.archive, 1399 &fixture.reachable(), 1400 ), 1401 Err(expected) 1402 ); 1403 } 1404 1405 let fixture = Fixture::new(); 1406 let other = fixture.root.path().join("other"); 1407 fs::create_dir(&other).expect("other repo"); 1408 git(&other, &["init", "--quiet"]); 1409 git(&other, &["config", "user.email", "fixture@example.invalid"]); 1410 git(&other, &["config", "user.name", "fixture"]); 1411 fs::write(other.join("other"), b"other").expect("other file"); 1412 git(&other, &["add", "."]); 1413 git(&other, &["commit", "--quiet", "-m", "other"]); 1414 git(&other, &["branch", "-M", "archive"]); 1415 let bad_archive = fixture.root.path().join("other.bundle"); 1416 let status = Command::new("git") 1417 .args(["bundle", "create"]) 1418 .arg(&bad_archive) 1419 .arg("refs/heads/archive") 1420 .current_dir(&other) 1421 .status() 1422 .expect("other bundle"); 1423 assert!(status.success()); 1424 assert_eq!( 1425 run_with( 1426 CommandMode::Write, 1427 &fixture.service, 1428 &bad_archive, 1429 &fixture.reachable(), 1430 ), 1431 Err(CommandError::InvalidSourceArchive) 1432 ); 1433 1434 let fixture = Fixture::new(); 1435 let oversized = fixture.root.path().join("oversized.bundle"); 1436 fs::File::create(&oversized) 1437 .and_then(|file| file.set_len(MAX_ARCHIVE_BYTES + 1)) 1438 .expect("sparse oversized archive"); 1439 assert_eq!( 1440 run_with( 1441 CommandMode::Write, 1442 &fixture.service, 1443 &oversized, 1444 &fixture.reachable(), 1445 ), 1446 Err(CommandError::InvalidSourceArchive) 1447 ); 1448 } 1449 1450 #[test] 1451 fn mixed_local_or_unlocked_lib_dependencies_fail_closed() { 1452 let fixture = Fixture::new(); 1453 let manifest = fixture.service.join(CARGO_MANIFEST); 1454 let mut text = fs::read_to_string(&manifest).expect("manifest"); 1455 text.push_str("radroots_core = { path = \"../lib/crates/core\" }\n"); 1456 fs::write(&manifest, text).expect("local Lib dependency"); 1457 git(&fixture.service, &["add", "."]); 1458 git( 1459 &fixture.service, 1460 &["commit", "--quiet", "-m", "local dependency"], 1461 ); 1462 assert_eq!( 1463 run_with( 1464 CommandMode::Write, 1465 &fixture.service, 1466 &fixture.archive, 1467 &fixture.reachable(), 1468 ), 1469 Err(CommandError::InvalidCargoManifest) 1470 ); 1471 1472 let fixture = Fixture::new(); 1473 let cargo_lock = fixture.service.join(CARGO_LOCK); 1474 let mut text = fs::read_to_string(&cargo_lock).expect("Cargo.lock"); 1475 text.push_str("\n[[package]]\nname = \"radroots_core\"\nversion = \"0.1.0-alpha\"\n"); 1476 fs::write(&cargo_lock, text).expect("unlocked Lib package"); 1477 git(&fixture.service, &["add", "."]); 1478 git( 1479 &fixture.service, 1480 &["commit", "--quiet", "-m", "unlocked dependency"], 1481 ); 1482 assert_eq!( 1483 run_with( 1484 CommandMode::Write, 1485 &fixture.service, 1486 &fixture.archive, 1487 &fixture.reachable(), 1488 ), 1489 Err(CommandError::InvalidCargoLock) 1490 ); 1491 1492 let fixture = Fixture::new(); 1493 let manifest = fixture.service.join(CARGO_MANIFEST); 1494 let mut text = fs::read_to_string(&manifest).expect("manifest"); 1495 text.push_str(&format!( 1496 "\n[patch.crates-io]\nradroots_core = {{ git = \"{LIB_REPOSITORY}\", rev = \"{}\", version = \"=0.1.0-alpha\" }}\n", 1497 fixture.revision 1498 )); 1499 fs::write(&manifest, text).expect("Lib patch"); 1500 git(&fixture.service, &["add", "."]); 1501 git(&fixture.service, &["commit", "--quiet", "-m", "Lib patch"]); 1502 assert_eq!( 1503 run_with( 1504 CommandMode::Write, 1505 &fixture.service, 1506 &fixture.archive, 1507 &fixture.reachable(), 1508 ), 1509 Err(CommandError::InvalidCargoManifest) 1510 ); 1511 } 1512 1513 #[test] 1514 fn floating_or_unbounded_nix_input_fails_closed() { 1515 for mutation in [ 1516 ("\"rev\":\"", "\"ref\":\"master\",\"rev\":\""), 1517 ( 1518 "sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=", 1519 "sha256-invalid", 1520 ), 1521 ("\"lastModified\":1,", "\"dir\":\"sub\",\"lastModified\":1,"), 1522 ] { 1523 let fixture = Fixture::new(); 1524 let path = fixture.service.join(FLAKE_LOCK); 1525 let current = fs::read_to_string(&path).expect("flake lock"); 1526 let mutated = if mutation.0 == "\"rev\":\"" { 1527 let second = current.rfind(mutation.0).expect("original revision field"); 1528 format!( 1529 "{}{}{}", 1530 ¤t[..second], 1531 mutation.1, 1532 ¤t[second + mutation.0.len()..] 1533 ) 1534 } else { 1535 current.replacen(mutation.0, mutation.1, 1) 1536 }; 1537 fs::write(&path, mutated).expect("mutate flake lock"); 1538 git(&fixture.service, &["add", "."]); 1539 git(&fixture.service, &["commit", "--quiet", "-m", "mutate"]); 1540 assert_eq!( 1541 run_with( 1542 CommandMode::Write, 1543 &fixture.service, 1544 &fixture.archive, 1545 &fixture.reachable(), 1546 ), 1547 Err(CommandError::InvalidFlakeLock) 1548 ); 1549 } 1550 } 1551 1552 #[test] 1553 fn current_lock_rejects_historical_bootstrap_and_independently_revisioned_nix() { 1554 for state in ["absent", "deferred", "qualified"] { 1555 let fixture = Fixture::new(); 1556 let manifest = fixture.service.join(CARGO_MANIFEST); 1557 let source = fs::read_to_string(&manifest).expect("manifest"); 1558 fs::write( 1559 &manifest, 1560 source.replace( 1561 "nix_material = \"bound\"", 1562 &format!("nix_material = \"{state}\""), 1563 ), 1564 ) 1565 .expect("historical metadata"); 1566 if state == "absent" { 1567 fs::remove_file(fixture.service.join(FLAKE_NIX)).expect("remove flake"); 1568 fs::remove_file(fixture.service.join(FLAKE_LOCK)).expect("remove lock"); 1569 } 1570 git(&fixture.service, &["add", "-A"]); 1571 git( 1572 &fixture.service, 1573 &["commit", "--quiet", "-m", "historical state"], 1574 ); 1575 assert_eq!( 1576 run_with( 1577 CommandMode::Write, 1578 &fixture.service, 1579 &fixture.archive, 1580 &fixture.reachable() 1581 ), 1582 Err(CommandError::InvalidServiceMetadata) 1583 ); 1584 assert!(!fixture.service.join(LOCK_FILENAME).exists()); 1585 } 1586 let fixture = Fixture::new(); 1587 for name in [FLAKE_NIX, FLAKE_LOCK] { 1588 let path = fixture.service.join(name); 1589 let source = fs::read_to_string(&path).expect("Nix input"); 1590 fs::write(&path, source.replace(&fixture.revision, &"b".repeat(40))) 1591 .expect("independent revision"); 1592 } 1593 git(&fixture.service, &["add", "."]); 1594 git( 1595 &fixture.service, 1596 &["commit", "--quiet", "-m", "independent revision"], 1597 ); 1598 assert_eq!( 1599 run_with( 1600 CommandMode::Write, 1601 &fixture.service, 1602 &fixture.archive, 1603 &fixture.reachable() 1604 ), 1605 Err(CommandError::InvalidNixMaterial) 1606 ); 1607 assert!(!fixture.service.join(LOCK_FILENAME).exists()); 1608 } 1609 1610 #[test] 1611 fn predecessor_source_lock_is_rejected_instead_of_forming_dual_authority() { 1612 for predecessor in PREDECESSOR_LOCK_FILENAMES { 1613 let fixture = Fixture::new(); 1614 fs::write(fixture.service.join(predecessor), b"historical lock") 1615 .expect("predecessor lock"); 1616 git(&fixture.service, &["add", "."]); 1617 git( 1618 &fixture.service, 1619 &["commit", "--quiet", "-m", "predecessor lock"], 1620 ); 1621 assert_eq!( 1622 run_with( 1623 CommandMode::Write, 1624 &fixture.service, 1625 &fixture.archive, 1626 &fixture.reachable() 1627 ), 1628 Err(CommandError::InvalidSourceLock) 1629 ); 1630 assert!(!fixture.service.join(LOCK_FILENAME).exists()); 1631 } 1632 } 1633 1634 #[test] 1635 fn partial_or_mismatched_nix_material_fails_closed() { 1636 for removed in [FLAKE_NIX, FLAKE_LOCK] { 1637 let fixture = Fixture::new(); 1638 fs::remove_file(fixture.service.join(removed)).expect("remove one Nix input"); 1639 git(&fixture.service, &["add", "-A"]); 1640 git( 1641 &fixture.service, 1642 &["commit", "--quiet", "-m", "partial Nix"], 1643 ); 1644 assert!(matches!( 1645 run_with( 1646 CommandMode::Write, 1647 &fixture.service, 1648 &fixture.archive, 1649 &fixture.reachable(), 1650 ), 1651 Err(CommandError::InvalidNixMaterial | CommandError::InvalidFlakeLock) 1652 )); 1653 } 1654 1655 let fixture = Fixture::new(); 1656 let expression = fixture.service.join(FLAKE_NIX); 1657 let source = fs::read_to_string(&expression).expect("flake expression"); 1658 fs::write( 1659 &expression, 1660 source.replace(&fixture.revision, &"b".repeat(40)), 1661 ) 1662 .expect("mismatch expression"); 1663 git(&fixture.service, &["add", "."]); 1664 git( 1665 &fixture.service, 1666 &["commit", "--quiet", "-m", "mismatch Nix"], 1667 ); 1668 assert_eq!( 1669 run_with( 1670 CommandMode::Write, 1671 &fixture.service, 1672 &fixture.archive, 1673 &fixture.reachable(), 1674 ), 1675 Err(CommandError::InvalidNixMaterial) 1676 ); 1677 } 1678 1679 #[test] 1680 fn flake_lock_rejects_each_independent_fixed_field_drift() { 1681 let fixture = Fixture::new(); 1682 let bytes = fs::read(fixture.service.join(FLAKE_LOCK)).expect("flake lock"); 1683 let canonical = serde_json::from_slice::<serde_json::Value>(&bytes).expect("flake json"); 1684 for (pointer, replacement) in [ 1685 ("/version", serde_json::json!(6)), 1686 ("/nodes/root/inputs/lib", serde_json::json!("other")), 1687 ("/nodes/lib/locked/type", serde_json::json!("git")), 1688 ("/nodes/lib/locked/owner", serde_json::json!("other")), 1689 ("/nodes/lib/locked/repo", serde_json::json!("other")), 1690 ("/nodes/lib/locked/rev", serde_json::json!("other")), 1691 ("/nodes/lib/locked/lastModified", serde_json::json!("1")), 1692 ( 1693 "/nodes/lib/locked/narHash", 1694 serde_json::json!("sha256-invalid"), 1695 ), 1696 ("/nodes/lib/original/type", serde_json::json!("git")), 1697 ("/nodes/lib/original/owner", serde_json::json!("other")), 1698 ("/nodes/lib/original/repo", serde_json::json!("other")), 1699 ("/nodes/lib/original/rev", serde_json::json!("other")), 1700 ] { 1701 let mut drifted = canonical.clone(); 1702 *drifted.pointer_mut(pointer).expect("governed field") = replacement; 1703 assert_eq!( 1704 validate_flake_lock(&serde_json::to_vec(&drifted).expect("flake json")), 1705 Err(CommandError::InvalidFlakeLock), 1706 "accepted drift at {pointer}" 1707 ); 1708 } 1709 1710 for (section, field) in [ 1711 ("locked", "extra"), 1712 ("original", "extra"), 1713 ("original", "ref"), 1714 ] { 1715 let mut drifted = canonical.clone(); 1716 drifted["nodes"]["lib"][section] 1717 .as_object_mut() 1718 .expect("flake section") 1719 .insert(field.into(), serde_json::json!("unexpected")); 1720 assert_eq!( 1721 validate_flake_lock(&serde_json::to_vec(&drifted).expect("flake json")), 1722 Err(CommandError::InvalidFlakeLock), 1723 "accepted {section}.{field}" 1724 ); 1725 } 1726 1727 let mut extra_node_field = canonical.clone(); 1728 extra_node_field["nodes"]["lib"]["extra"] = serde_json::json!(true); 1729 assert_eq!( 1730 validate_flake_lock(&serde_json::to_vec(&extra_node_field).expect("flake json")), 1731 Err(CommandError::InvalidFlakeLock) 1732 ); 1733 1734 let mut duplicate = canonical.clone(); 1735 duplicate["nodes"]["lib2"] = duplicate["nodes"]["lib"].clone(); 1736 assert_eq!( 1737 validate_flake_lock(&serde_json::to_vec(&duplicate).expect("flake json")), 1738 Err(CommandError::InvalidFlakeLock) 1739 ); 1740 1741 let aliased = String::from_utf8(bytes.clone()) 1742 .expect("flake UTF-8") 1743 .replacen("\"lib\":\"lib\"", "\"other\":\"lib\"", 1); 1744 assert_eq!( 1745 validate_flake_lock(aliased.as_bytes()), 1746 Err(CommandError::InvalidFlakeLock) 1747 ); 1748 let duplicated = String::from_utf8(bytes).expect("flake UTF-8").replacen( 1749 "\"version\":7", 1750 "\"version\":7,\"version\":7", 1751 1, 1752 ); 1753 assert_eq!( 1754 validate_flake_lock(duplicated.as_bytes()), 1755 Err(CommandError::InvalidFlakeLock) 1756 ); 1757 } 1758 1759 #[test] 1760 fn service_metadata_and_catalog_reject_independent_field_drift() { 1761 let fixture = Fixture::new(); 1762 let bytes = fs::read(fixture.service.join(CARGO_MANIFEST)).expect("manifest"); 1763 let canonical = parse_toml(&bytes, CommandError::InvalidCargoManifest).expect("manifest"); 1764 for (field, replacement) in [ 1765 ("service", toml::Value::Integer(1)), 1766 ("host_feature_profile", toml::Value::String("other".into())), 1767 ("nix_material", toml::Value::String("other".into())), 1768 ("config_contract_version", toml::Value::Integer(0)), 1769 ("state_contract_version", toml::Value::Integer(0)), 1770 ("admin_contract_version", toml::Value::Integer(0)), 1771 ("status_contract_version", toml::Value::Integer(0)), 1772 ("provider_contract_version", toml::Value::Integer(0)), 1773 ] { 1774 let mut drifted = canonical.clone(); 1775 drifted["workspace"]["metadata"]["radroots"]["service_source_lock"][field] = 1776 replacement; 1777 assert_eq!( 1778 parse_service_metadata(&drifted), 1779 Err(CommandError::InvalidServiceMetadata), 1780 "accepted metadata drift at {field}" 1781 ); 1782 } 1783 let mut extra = canonical; 1784 extra["workspace"]["metadata"]["radroots"]["service_source_lock"] 1785 .as_table_mut() 1786 .expect("metadata table") 1787 .insert("extra".into(), toml::Value::Integer(1)); 1788 assert_eq!( 1789 parse_service_metadata(&extra), 1790 Err(CommandError::InvalidServiceMetadata) 1791 ); 1792 1793 let catalog = br#"schema = "radroots.workspace.catalog.v2" 1794 architecture = "radroots.crates.release.v2" 1795 version = "0.1.0-alpha" 1796 rust_version = "1.99.0" 1797 edition = "2024" 1798 resolver = "3" 1799 package_count = 2 1800 1801 [[package]] 1802 name = "radroots_core" 1803 1804 [[package]] 1805 name = "radroots_service_host" 1806 "#; 1807 let canonical = parse_toml(catalog, CommandError::InvalidSourceArchive).expect("catalog"); 1808 for (field, replacement) in [ 1809 ("schema", toml::Value::String("other".into())), 1810 ("architecture", toml::Value::String("other".into())), 1811 ("version", toml::Value::String("other".into())), 1812 ("package_count", toml::Value::Integer(1)), 1813 ] { 1814 let mut drifted = canonical.clone(); 1815 drifted[field] = replacement; 1816 assert_eq!( 1817 catalog_package_names(toml::to_string(&drifted).expect("catalog").as_bytes()), 1818 Err(CommandError::InvalidSourceArchive), 1819 "accepted catalog drift at {field}" 1820 ); 1821 } 1822 let mut duplicate = canonical.clone(); 1823 duplicate["package"][1]["name"] = toml::Value::String("radroots_core".into()); 1824 assert_eq!( 1825 catalog_package_names(toml::to_string(&duplicate).expect("catalog").as_bytes()), 1826 Err(CommandError::InvalidSourceArchive) 1827 ); 1828 let mut missing_host = canonical; 1829 missing_host["package"][1]["name"] = toml::Value::String("radroots_other".into()); 1830 assert_eq!( 1831 catalog_package_names(toml::to_string(&missing_host).expect("catalog").as_bytes()), 1832 Err(CommandError::InvalidSourceArchive) 1833 ); 1834 } 1835 1836 #[test] 1837 fn manifest_and_cargo_lock_reject_each_independent_dependency_drift() { 1838 let revision = "a".repeat(40); 1839 let canonical = format!( 1840 "[dependencies]\nradroots_service_host = {{ git = \"{LIB_REPOSITORY}\", rev = \"{revision}\", version = \"{LIB_VERSION_REQUIREMENT}\" }}\n" 1841 ); 1842 for (from, to) in [ 1843 (LIB_REPOSITORY, "https://example.invalid/lib"), 1844 (LIB_VERSION_REQUIREMENT, "=0.2.0"), 1845 (revision.as_str(), "invalid"), 1846 ] { 1847 let value = 1848 toml::from_str::<toml::Value>(&canonical.replacen(from, to, 1)).expect("manifest"); 1849 assert_eq!( 1850 validate_manifest_node( 1851 &value, 1852 None, 1853 false, 1854 false, 1855 None, 1856 &mut ManifestState::default() 1857 ), 1858 Err(CommandError::InvalidCargoManifest) 1859 ); 1860 } 1861 for forbidden in ["branch", "tag", "path"] { 1862 let mutated = canonical.replacen( 1863 "version = \"=0.1.0-alpha\"", 1864 &format!("version = \"=0.1.0-alpha\", {forbidden} = \"forbidden\""), 1865 1, 1866 ); 1867 let value = toml::from_str::<toml::Value>(&mutated).expect("manifest"); 1868 assert_eq!( 1869 validate_manifest_node( 1870 &value, 1871 None, 1872 false, 1873 false, 1874 None, 1875 &mut ManifestState::default() 1876 ), 1877 Err(CommandError::InvalidCargoManifest), 1878 "accepted {forbidden}" 1879 ); 1880 } 1881 let value = toml::from_str::<toml::Value>(&canonical).expect("manifest"); 1882 assert_eq!( 1883 validate_manifest_node( 1884 &value, 1885 None, 1886 true, 1887 false, 1888 None, 1889 &mut ManifestState::default() 1890 ), 1891 Err(CommandError::InvalidCargoManifest) 1892 ); 1893 let mut state = ManifestState { 1894 revision: Some("b".repeat(40)), 1895 ..ManifestState::default() 1896 }; 1897 assert_eq!( 1898 validate_manifest_node(&value, None, false, false, None, &mut state), 1899 Err(CommandError::InvalidCargoManifest) 1900 ); 1901 1902 let packages = BTreeSet::from([HOST_PACKAGE.to_owned(), "radroots_core".to_owned()]); 1903 let expected = format!("git+{LIB_REPOSITORY}?rev={revision}#{revision}"); 1904 for document in [ 1905 format!( 1906 "version = 4\n\n[[package]]\nname = \"{HOST_PACKAGE}\"\nversion = \"0.1.0-alpha\"\n" 1907 ), 1908 format!( 1909 "version = 4\n\n[[package]]\nname = \"{HOST_PACKAGE}\"\nversion = \"0.1.0-alpha\"\nsource = \"other\"\n" 1910 ), 1911 format!( 1912 "version = 4\n\n[[package]]\nname = \"{HOST_PACKAGE}\"\nversion = \"0.2.0\"\nsource = \"{expected}\"\n" 1913 ), 1914 format!( 1915 "version = 4\n\n[[package]]\nname = \"radroots_core\"\nversion = \"0.1.0-alpha\"\nsource = \"{expected}\"\n" 1916 ), 1917 "version = 4\n".to_owned(), 1918 ] { 1919 assert_eq!( 1920 validate_cargo_lock(document.as_bytes(), &revision, &packages), 1921 Err(CommandError::InvalidCargoLock) 1922 ); 1923 } 1924 } 1925 1926 #[test] 1927 fn archive_and_manifest_filesystem_admission_is_fail_closed() { 1928 let root = TempDir::new().expect("filesystem fixture"); 1929 let empty = root.path().join("empty"); 1930 fs::write(&empty, b"").expect("empty file"); 1931 assert!(matches!( 1932 validate_archive(Path::new("relative"), &"a".repeat(40)), 1933 Err(CommandError::InvalidSourceArchive) 1934 )); 1935 assert!(matches!( 1936 validate_archive(root.path(), &"a".repeat(40)), 1937 Err(CommandError::InvalidSourceArchive) 1938 )); 1939 assert!(matches!( 1940 validate_archive(&empty, &"a".repeat(40)), 1941 Err(CommandError::InvalidSourceArchive) 1942 )); 1943 1944 let no_manifest = root.path().join("no-manifest"); 1945 fs::create_dir(&no_manifest).expect("empty tree"); 1946 assert_eq!( 1947 validate_cargo_manifests(&no_manifest, None), 1948 Err(CommandError::InvalidCargoManifest) 1949 ); 1950 let no_dependency = root.path().join("no-dependency"); 1951 fs::create_dir(&no_dependency).expect("manifest tree"); 1952 fs::write( 1953 no_dependency.join(CARGO_MANIFEST), 1954 "[workspace]\nresolver = \"3\"\n", 1955 ) 1956 .expect("manifest"); 1957 assert_eq!( 1958 validate_cargo_manifests(&no_dependency, None), 1959 Err(CommandError::InvalidCargoManifest) 1960 ); 1961 1962 #[cfg(unix)] 1963 { 1964 let archive_link = root.path().join("archive-link"); 1965 std::os::unix::fs::symlink(&empty, &archive_link).expect("archive symlink"); 1966 assert!(matches!( 1967 validate_archive(&archive_link, &"a".repeat(40)), 1968 Err(CommandError::InvalidSourceArchive) 1969 )); 1970 let manifest_link_root = root.path().join("manifest-link"); 1971 fs::create_dir(&manifest_link_root).expect("manifest symlink tree"); 1972 std::os::unix::fs::symlink(&empty, manifest_link_root.join(CARGO_MANIFEST)) 1973 .expect("manifest symlink"); 1974 assert_eq!( 1975 validate_cargo_manifests(&manifest_link_root, None), 1976 Err(CommandError::InvalidCargoManifest) 1977 ); 1978 } 1979 } 1980 1981 #[test] 1982 fn service_manifest_discovery_skips_swiftpm_build_output_only() { 1983 let fixture = Fixture::new(); 1984 let swiftpm_checkout = fixture.service.join(".build/checkouts/dependency"); 1985 fs::create_dir_all(&swiftpm_checkout).expect("SwiftPM checkout directory"); 1986 fs::write(swiftpm_checkout.join(CARGO_MANIFEST), "not valid TOML") 1987 .expect("SwiftPM build manifest"); 1988 assert_eq!( 1989 validate_cargo_manifests(&fixture.service, None), 1990 Ok(fixture.revision) 1991 ); 1992 1993 let source_lookalike = fixture.service.join(".builder"); 1994 fs::create_dir(&source_lookalike).expect("source lookalike directory"); 1995 fs::write(source_lookalike.join(CARGO_MANIFEST), "not valid TOML") 1996 .expect("source lookalike manifest"); 1997 assert_eq!( 1998 validate_cargo_manifests(&fixture.service, None), 1999 Err(CommandError::InvalidCargoManifest) 2000 ); 2001 } 2002 2003 #[test] 2004 fn source_lock_output_rejects_symlink_replacement() { 2005 let fixture = Fixture::new(); 2006 let target = fixture.root.path().join("foreign"); 2007 fs::write(&target, b"foreign").expect("foreign"); 2008 #[cfg(unix)] 2009 std::os::unix::fs::symlink(&target, fixture.service.join(LOCK_FILENAME)).expect("symlink"); 2010 #[cfg(unix)] 2011 assert_eq!( 2012 run_with( 2013 CommandMode::Write, 2014 &fixture.service, 2015 &fixture.archive, 2016 &fixture.reachable(), 2017 ), 2018 Err(CommandError::WriteFailure) 2019 ); 2020 #[cfg(unix)] 2021 assert_eq!(fs::read(&target).expect("foreign remains"), b"foreign"); 2022 } 2023 2024 #[test] 2025 fn low_level_source_lock_admission_branches_are_qualified() { 2026 let root = TempDir::new().expect("low-level source-lock fixture"); 2027 let regular = root.path().join("regular"); 2028 fs::write(®ular, b"same").expect("regular file"); 2029 assert_eq!( 2030 read_bounded_regular(®ular, 4, CommandError::InvalidSourceLock) 2031 .expect("bounded regular file"), 2032 b"same" 2033 ); 2034 assert_eq!( 2035 validate_service_root(Path::new("relative")), 2036 Err(CommandError::InvalidServiceRoot) 2037 ); 2038 assert_eq!( 2039 validate_service_root(®ular), 2040 Err(CommandError::InvalidServiceRoot) 2041 ); 2042 2043 let directory = root.path().join("directory"); 2044 fs::create_dir(&directory).expect("directory fixture"); 2045 assert_eq!( 2046 read_bounded_regular(&directory, 4, CommandError::InvalidSourceLock), 2047 Err(CommandError::InvalidSourceLock) 2048 ); 2049 let oversized = root.path().join("oversized"); 2050 fs::write(&oversized, b"12345").expect("oversized file"); 2051 assert_eq!( 2052 read_bounded_regular(&oversized, 4, CommandError::InvalidSourceLock), 2053 Err(CommandError::InvalidSourceLock) 2054 ); 2055 2056 #[cfg(unix)] 2057 { 2058 let symlink = root.path().join("regular-link"); 2059 std::os::unix::fs::symlink(®ular, &symlink).expect("regular symlink"); 2060 assert_eq!( 2061 validate_service_root(&symlink), 2062 Err(CommandError::InvalidServiceRoot) 2063 ); 2064 assert_eq!( 2065 read_bounded_regular(&symlink, 4, CommandError::InvalidSourceLock), 2066 Err(CommandError::InvalidSourceLock) 2067 ); 2068 } 2069 2070 let repository = root.path().join("repository"); 2071 fs::create_dir(&repository).expect("repository"); 2072 git(&repository, &["init", "--quiet"]); 2073 let child = repository.join("child"); 2074 fs::create_dir(&child).expect("nested directory"); 2075 assert_eq!( 2076 validate_service_root(&child), 2077 Err(CommandError::InvalidServiceRoot) 2078 ); 2079 2080 let empty_catalog = br#"schema = "radroots.workspace.catalog.v2" 2081 architecture = "radroots.crates.release.v2" 2082 version = "0.1.0-alpha" 2083 package_count = 0 2084 package = [] 2085 "#; 2086 assert_eq!( 2087 catalog_package_names(empty_catalog), 2088 Err(CommandError::InvalidSourceArchive) 2089 ); 2090 2091 let dependency = toml::Value::String("=0.1.0-alpha".into()); 2092 let packages = BTreeSet::from([HOST_PACKAGE.to_owned()]); 2093 assert_eq!( 2094 validate_manifest_node( 2095 &dependency, 2096 Some(HOST_PACKAGE), 2097 false, 2098 true, 2099 Some(&packages), 2100 &mut ManifestState::default(), 2101 ), 2102 Err(CommandError::InvalidCargoManifest) 2103 ); 2104 2105 assert_eq!( 2106 validate_flake_lock(br#"{"nodes":{"root":{"inputs":{}}},"root":"root","version":7}"#,), 2107 Err(CommandError::InvalidFlakeLock) 2108 ); 2109 assert_eq!( 2110 validate_flake_lock( 2111 br#"{"nodes":{"root":{"inputs":{"lib":"lib"}},"lib":{"original":{"owner":"radrootslabs","repo":"lib"}}},"root":"root","version":7}"#, 2112 ), 2113 Err(CommandError::InvalidFlakeLock) 2114 ); 2115 2116 assert!(!valid_nix_sha256("not-a-digest")); 2117 assert!(!valid_nix_sha256( 2118 "sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" 2119 )); 2120 assert!(!valid_nix_sha256( 2121 "sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA?=" 2122 )); 2123 2124 let mut oversized_stdout = Command::new("sh"); 2125 oversized_stdout.args(["-c", "printf 12345"]); 2126 assert_eq!(command_stdout(&mut oversized_stdout, 4), Err(())); 2127 let mut failed_stdout = Command::new("sh"); 2128 failed_stdout.args(["-c", "exit 7"]); 2129 assert_eq!(command_stdout(&mut failed_stdout, 4), Err(())); 2130 assert_eq!( 2131 git_status(root.path(), ["rev-parse", "--verify", "refs/heads/missing"]), 2132 Err(()) 2133 ); 2134 } 2135 2136 #[test] 2137 fn operational_diagnostics_are_fixed_and_source_free() { 2138 let errors = [ 2139 CommandError::InvalidServiceRoot, 2140 CommandError::DirtyServiceSource, 2141 CommandError::InvalidServiceMetadata, 2142 CommandError::InvalidCargoManifest, 2143 CommandError::InvalidCargoLock, 2144 CommandError::InvalidArtifactContract, 2145 CommandError::InvalidNixMaterial, 2146 CommandError::InvalidFlakeLock, 2147 CommandError::InvalidToolchain, 2148 CommandError::InvalidSourceArchive, 2149 CommandError::UnreachableRevision, 2150 CommandError::InvalidSourceLock, 2151 CommandError::StaleSourceLock, 2152 CommandError::WriteFailure, 2153 ]; 2154 for error in errors { 2155 assert!(error.source().is_none()); 2156 let rendered = format!("{error:?} {error}"); 2157 assert!(!rendered.contains("myc")); 2158 assert!(!rendered.contains("radrootslabs")); 2159 assert!(!rendered.contains("/tmp")); 2160 } 2161 } 2162 2163 #[test] 2164 fn archive_rejects_obsolete_committed_lib_compiler_inputs() { 2165 for name in [CARGO_MANIFEST, RUST_TOOLCHAIN, CATALOG_RELATIVE] { 2166 let fixture = Fixture::new(); 2167 let lib = fixture.root.path().join("lib"); 2168 let path = lib.join(name); 2169 let original = fs::read_to_string(&path).expect("Lib input"); 2170 fs::write(&path, original.replace("1.99.0", "1.97.1")).expect("obsolete Lib input"); 2171 git(&lib, &["add", "."]); 2172 git( 2173 &lib, 2174 &["commit", "--quiet", "-m", "obsolete compiler input"], 2175 ); 2176 let revision = 2177 String::from_utf8(git_stdout(&lib, ["rev-parse", "HEAD"], 128).expect("revision")) 2178 .expect("UTF-8") 2179 .trim() 2180 .to_owned(); 2181 let bundle = fixture.root.path().join("obsolete.bundle"); 2182 let status = Command::new("git") 2183 .args(["bundle", "create"]) 2184 .arg(&bundle) 2185 .arg("refs/heads/archive") 2186 .current_dir(&lib) 2187 .status() 2188 .expect("bundle"); 2189 assert!(status.success()); 2190 assert!( 2191 matches!( 2192 validate_archive(&bundle, &revision), 2193 Err(CommandError::InvalidSourceArchive) 2194 ), 2195 "{name}" 2196 ); 2197 } 2198 } 2199 2200 #[test] 2201 fn current_artifact_contract_must_exist_in_the_committed_service_revision() { 2202 let fixture = Fixture::new(); 2203 let artifact = fixture 2204 .service 2205 .join("contracts/release/myc-artifact-contract.v4.json"); 2206 fs::remove_file(&artifact).expect("remove contract"); 2207 git(&fixture.service, &["add", "-A"]); 2208 git( 2209 &fixture.service, 2210 &["commit", "--quiet", "-m", "missing artifact contract"], 2211 ); 2212 assert_eq!( 2213 run_with( 2214 CommandMode::Write, 2215 &fixture.service, 2216 &fixture.archive, 2217 &fixture.reachable() 2218 ), 2219 Err(CommandError::InvalidArtifactContract) 2220 ); 2221 assert!(!fixture.service.join(LOCK_FILENAME).exists()); 2222 } 2223 }