lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

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(&current)
    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(&current)
    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                     &current[..second],
   1531                     mutation.1,
   1532                     &current[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(&regular, b"same").expect("regular file");
   2029         assert_eq!(
   2030             read_bounded_regular(&regular, 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(&regular),
   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(&regular, &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 }