main.rs (43759B)
1 #![cfg_attr(coverage_nightly, feature(coverage_attribute))] 2 #![forbid(unsafe_code)] 3 #![recursion_limit = "256"] 4 5 // These release-qualification modules are executable integration boundaries: 6 // their governed lanes invoke external toolchains, fuzzers, package builds, 7 // advisory scanners, SBOM generators, and target checks. They are exercised 8 // by their dedicated release gates and must not recursively execute inside 9 // xtask's unit-coverage process. 10 mod advisory_snapshot; 11 #[cfg_attr(coverage_nightly, coverage(off))] 12 mod api_qualification; 13 #[cfg_attr(coverage_nightly, coverage(off))] 14 mod architecture; 15 mod artifact_admission; 16 mod bounded_process; 17 #[cfg_attr(coverage_nightly, coverage(off))] 18 mod build_control; 19 mod build_output; 20 #[cfg_attr(coverage_nightly, coverage(off))] 21 mod catalog; 22 mod compiler_preparation; 23 #[cfg_attr(coverage_nightly, coverage(off))] 24 mod consolidation; 25 #[cfg_attr(coverage_nightly, coverage(off))] 26 mod contract; 27 mod coverage; 28 #[cfg_attr(coverage_nightly, coverage(off))] 29 mod dto_roots; 30 mod exact_tree_archive; 31 #[cfg_attr(coverage_nightly, coverage(off))] 32 mod fuzz_qualification; 33 #[cfg_attr(coverage_nightly, coverage(off))] 34 mod generate; 35 #[cfg_attr(coverage_nightly, coverage(off))] 36 mod hygiene; 37 #[cfg_attr(coverage_nightly, coverage(off))] 38 mod portable_qualification; 39 #[cfg_attr(coverage_nightly, coverage(off))] 40 mod release_graph; 41 mod release_preflight; 42 #[cfg_attr(coverage_nightly, coverage(off))] 43 mod release_qualification; 44 mod rshr_202_step_298_gate; 45 mod rshr_202_step_298_platform; 46 mod rshr_202_step_299_gate; 47 mod rshr_202_step_304_gate; 48 mod rshr_202_step_305_gate; 49 mod rshr_202_step_306_gate; 50 mod safe_artifact_io; 51 #[cfg_attr(coverage_nightly, coverage(off))] 52 mod safety_qualification; 53 #[cfg_attr(coverage_nightly, coverage(off))] 54 mod sdk_generation; 55 mod service_build_qualification; 56 mod service_release_artifacts; 57 mod service_repro_install; 58 mod service_source_lock; 59 mod service_source_lock_command; 60 mod service_source_lock_nix; 61 mod service_source_lock_parts; 62 #[cfg(test)] 63 mod service_source_lock_v3; 64 mod service_source_lock_v4; 65 mod shared_protocol; 66 #[cfg_attr(coverage_nightly, coverage(off))] 67 mod supply_chain_qualification; 68 #[cfg_attr(coverage_nightly, coverage(off))] 69 mod target_qualification; 70 71 use clap::{Parser, Subcommand, ValueEnum}; 72 use std::env; 73 use std::path::{Path, PathBuf}; 74 use std::process::ExitCode; 75 76 #[derive(Debug, Parser)] 77 #[command(name = "xtask", disable_help_subcommand = true)] 78 struct Cli { 79 #[command(subcommand)] 80 command: XtaskCommand, 81 } 82 83 #[derive(Debug, Subcommand)] 84 enum XtaskCommand { 85 AdvisorySnapshotSelfTest, 86 #[command(hide = true)] 87 AdvisorySnapshotFixtureScanner { 88 #[arg(long, default_value = "report")] 89 mode: String, 90 }, 91 Architecture, 92 ArchitectureCi, 93 ArchitectureSourceExportCi, 94 BoundedProcessSelfTest, 95 SafeArtifactIoSelfTest, 96 CheckApiBoundaries, 97 CheckDependencyBoundaries, 98 Check { 99 #[arg(long)] 100 group: String, 101 #[arg(long, value_enum, default_value_t = GroupOperation::Check)] 102 operation: GroupOperation, 103 #[arg(long)] 104 execute: bool, 105 #[arg(long)] 106 include_reserved: bool, 107 }, 108 Catalog { 109 #[command(subcommand)] 110 command: CatalogCommand, 111 }, 112 #[command(trailing_var_arg = true)] 113 Contract { 114 #[arg(allow_hyphen_values = true)] 115 args: Vec<String>, 116 }, 117 #[command(trailing_var_arg = true)] 118 Consolidation { 119 #[arg(allow_hyphen_values = true)] 120 args: Vec<String>, 121 }, 122 #[command(trailing_var_arg = true)] 123 Coverage { 124 #[arg(allow_hyphen_values = true)] 125 args: Vec<String>, 126 }, 127 #[command(name = "dto-roots", trailing_var_arg = true)] 128 DtoRoots { 129 #[arg(allow_hyphen_values = true)] 130 args: Vec<String>, 131 }, 132 #[command(trailing_var_arg = true)] 133 Generate { 134 #[arg(allow_hyphen_values = true)] 135 args: Vec<String>, 136 }, 137 #[command(trailing_var_arg = true)] 138 Hygiene { 139 #[arg(allow_hyphen_values = true)] 140 args: Vec<String>, 141 }, 142 #[command(trailing_var_arg = true)] 143 Release { 144 #[arg(allow_hyphen_values = true)] 145 args: Vec<String>, 146 }, 147 #[command(name = "rshr-step-298-gate", hide = true)] 148 RshrStep298Gate { 149 #[arg(long)] 150 step: u16, 151 #[arg(long)] 152 check_id: String, 153 #[arg(long)] 154 source_revision: String, 155 #[arg(long)] 156 source_tree: String, 157 #[arg(long)] 158 candidate_digest: String, 159 #[arg(long)] 160 platform: String, 161 #[arg(long)] 162 execution_request_sha256: String, 163 }, 164 #[command(name = "rshr-step-298-platform-probe", hide = true)] 165 RshrStep298PlatformProbe, 166 #[command(name = "rshr-step-299-gate", hide = true)] 167 RshrStep299Gate { 168 #[arg(long)] 169 step: u16, 170 #[arg(long)] 171 check_id: String, 172 #[arg(long)] 173 source_revision: String, 174 #[arg(long)] 175 source_tree: String, 176 #[arg(long)] 177 candidate_digest: String, 178 #[arg(long)] 179 platform: String, 180 #[arg(long)] 181 execution_request_sha256: String, 182 }, 183 #[command(name = "rshr-step-304-gate", hide = true)] 184 RshrStep304Gate { 185 #[arg(long)] 186 step: u16, 187 #[arg(long)] 188 check_id: String, 189 #[arg(long)] 190 source_revision: String, 191 #[arg(long)] 192 source_tree: String, 193 #[arg(long)] 194 candidate_digest: String, 195 #[arg(long)] 196 platform: String, 197 #[arg(long)] 198 execution_request_sha256: String, 199 }, 200 #[command(name = "rshr-step-305-gate", hide = true)] 201 RshrStep305Gate { 202 #[arg(long)] 203 step: u16, 204 #[arg(long)] 205 check_id: String, 206 #[arg(long)] 207 source_revision: String, 208 #[arg(long)] 209 source_tree: String, 210 #[arg(long)] 211 candidate_digest: String, 212 #[arg(long)] 213 platform: String, 214 #[arg(long)] 215 execution_request_sha256: String, 216 }, 217 #[command(name = "rshr-step-306-gate", hide = true)] 218 RshrStep306Gate { 219 #[arg(long)] 220 step: u16, 221 #[arg(long)] 222 check_id: String, 223 #[arg(long)] 224 source_revision: String, 225 #[arg(long)] 226 source_tree: String, 227 #[arg(long)] 228 candidate_digest: String, 229 #[arg(long)] 230 platform: String, 231 #[arg(long)] 232 execution_request_sha256: String, 233 }, 234 SourceLock { 235 #[arg(long)] 236 consumer_root: PathBuf, 237 }, 238 ServiceSourceLock { 239 #[arg(long, value_enum)] 240 mode: ServiceSourceLockMode, 241 #[arg(long)] 242 service_root: PathBuf, 243 #[arg(long)] 244 source_archive: PathBuf, 245 }, 246 ServiceReleaseArtifacts { 247 #[arg(long, value_enum)] 248 mode: ServiceReleaseArtifactMode, 249 #[arg(long)] 250 service_root: PathBuf, 251 #[arg(long)] 252 lib_root: PathBuf, 253 #[arg(long)] 254 input_root: PathBuf, 255 #[arg(long)] 256 output_root: PathBuf, 257 #[arg(long)] 258 target: String, 259 #[arg(long)] 260 source_date_epoch: u32, 261 #[arg(long)] 262 candidate_digest: String, 263 }, 264 ServiceReproInstall { 265 #[arg(long)] 266 plan: PathBuf, 267 #[arg(long)] 268 source_root: PathBuf, 269 #[arg(long)] 270 root_preimage_root: PathBuf, 271 #[arg(long)] 272 predecessor_artifact_root: PathBuf, 273 #[arg(long)] 274 git_executable: PathBuf, 275 #[arg(long)] 276 adapter_executable: PathBuf, 277 #[arg(long)] 278 output: PathBuf, 279 }, 280 Source { 281 #[command(subcommand)] 282 command: SourceCommand, 283 }, 284 Artifact { 285 #[arg(long, value_enum)] 286 product: ArtifactProduct, 287 #[arg(long, value_enum)] 288 target: ArtifactTarget, 289 #[arg(long, value_enum)] 290 language: ArtifactLanguage, 291 #[arg(long, value_enum)] 292 mode: ArtifactMode, 293 #[arg(long)] 294 consumer_root: PathBuf, 295 #[arg(long)] 296 source_root: PathBuf, 297 #[arg(long)] 298 output: PathBuf, 299 #[arg(long)] 300 source_date_epoch: u64, 301 #[arg(long)] 302 builder_id: String, 303 #[arg(long, value_delimiter = ',')] 304 features: Vec<String>, 305 }, 306 } 307 308 #[derive(Clone, Copy, Debug, Subcommand)] 309 enum CatalogCommand { 310 Check, 311 Write, 312 } 313 314 #[derive(Clone, Copy, Debug, ValueEnum)] 315 enum GroupOperation { 316 Check, 317 Test, 318 Clippy, 319 } 320 321 #[derive(Clone, Copy, Debug, ValueEnum)] 322 enum ArtifactMode { 323 Check, 324 Write, 325 } 326 327 #[derive(Clone, Copy, Debug, ValueEnum)] 328 enum SourceMode { 329 Prefetch, 330 Offline, 331 } 332 333 #[derive(Clone, Copy, Debug, ValueEnum)] 334 enum ServiceSourceLockMode { 335 Check, 336 Write, 337 Prepare, 338 } 339 340 #[derive(Clone, Copy, Debug, ValueEnum)] 341 enum ServiceReleaseArtifactMode { 342 Check, 343 Write, 344 } 345 346 #[derive(Clone, Copy, Debug, ValueEnum)] 347 enum ArtifactProduct { 348 Sdk, 349 } 350 351 impl ArtifactProduct { 352 fn as_str(self) -> &'static str { 353 match self { 354 Self::Sdk => "sdk", 355 } 356 } 357 } 358 359 #[derive(Clone, Copy, Debug, ValueEnum)] 360 enum ArtifactTarget { 361 Typescript, 362 Wasm, 363 Ffi, 364 Linux, 365 Macos, 366 Windows, 367 } 368 369 impl ArtifactTarget { 370 fn as_str(self) -> &'static str { 371 match self { 372 Self::Typescript => "typescript", 373 Self::Wasm => "wasm", 374 Self::Ffi => "ffi", 375 Self::Linux => "linux", 376 Self::Macos => "macos", 377 Self::Windows => "windows", 378 } 379 } 380 } 381 382 #[derive(Clone, Copy, Debug, ValueEnum)] 383 enum ArtifactLanguage { 384 Typescript, 385 Swift, 386 Kotlin, 387 Javascript, 388 } 389 390 impl ArtifactLanguage { 391 fn as_str(self) -> &'static str { 392 match self { 393 Self::Typescript => "typescript", 394 Self::Swift => "swift", 395 Self::Kotlin => "kotlin", 396 Self::Javascript => "javascript", 397 } 398 } 399 } 400 401 #[derive(Debug, Subcommand)] 402 enum SourceCommand { 403 Materialize { 404 #[arg(long)] 405 consumer_root: PathBuf, 406 #[arg(long)] 407 cache_root: PathBuf, 408 #[arg(long, value_enum)] 409 mode: SourceMode, 410 }, 411 ArchiveVerify { 412 #[arg(long)] 413 archive: PathBuf, 414 #[arg(long)] 415 sha256: String, 416 }, 417 ArchiveCreate { 418 #[arg(long)] 419 source_root: PathBuf, 420 #[arg(long)] 421 revision: String, 422 #[arg(long)] 423 output: PathBuf, 424 }, 425 } 426 427 fn usage() { 428 eprintln!("usage:"); 429 eprintln!(" cargo xtask architecture"); 430 eprintln!(" cargo xtask architecture-ci"); 431 eprintln!(" cargo xtask architecture-source-export-ci"); 432 eprintln!(" cargo xtask advisory-snapshot-self-test"); 433 eprintln!(" cargo xtask bounded-process-self-test"); 434 eprintln!(" cargo xtask safe-artifact-io-self-test"); 435 eprintln!(" cargo xtask check-api-boundaries"); 436 eprintln!(" cargo xtask check-dependency-boundaries"); 437 eprintln!(" cargo xtask check --group <group> [--operation check|test|clippy] [--execute]"); 438 eprintln!(" cargo xtask catalog check|write"); 439 eprintln!(" cargo xtask contract validate"); 440 eprintln!(" cargo xtask contract event-contract-registry-v7 [--write]"); 441 eprintln!(" cargo xtask contract knowledge-manifest [--write]"); 442 eprintln!(" cargo xtask consolidation baseline"); 443 eprintln!(" cargo xtask consolidation history [--archive-root <absolute-directory>]"); 444 eprintln!(" cargo xtask consolidation history-rehearsal"); 445 eprintln!( 446 " cargo xtask consolidation import-verify --source <id> --source-root <absolute-directory> --filtered-root <absolute-directory> --mode <check|write>" 447 ); 448 eprintln!(" cargo xtask dto-roots --check|--write"); 449 eprintln!(" cargo xtask generate protocol --check|--write"); 450 eprintln!(" cargo xtask release preflight"); 451 eprintln!(" cargo xtask release qualify-features"); 452 eprintln!(" cargo xtask release qualify-graph"); 453 eprintln!(" cargo xtask release qualify-api"); 454 eprintln!(" cargo xtask release qualify-fuzz"); 455 eprintln!(" cargo xtask release qualify-portable"); 456 eprintln!(" cargo xtask release qualify-safety"); 457 eprintln!(" cargo xtask release qualify-supply-chain"); 458 eprintln!(" cargo xtask release qualify-targets"); 459 eprintln!(" cargo xtask coverage run-crate --crate <crate> [--out <dir>]"); 460 eprintln!(" cargo xtask coverage required-crates"); 461 eprintln!(" cargo xtask coverage workspace-crates"); 462 eprintln!( 463 " cargo xtask coverage report --scope <scope> --summary <file> --lcov <file> --out <file> [--policy-gate | (--fail-under-exec-lines <pct> --fail-under-functions <pct> --fail-under-regions <pct> --fail-under-branches <pct> [--require-branches])]" 464 ); 465 eprintln!( 466 " cargo xtask coverage report-missing --scope <scope> --out <file> --reason <reason>" 467 ); 468 eprintln!( 469 " cargo xtask coverage refresh-summary [--reports-root <dir>] [--out <file>] [--status-out <file>]" 470 ); 471 eprintln!(" cargo xtask hygiene forbidden-identifiers"); 472 eprintln!( 473 " cargo xtask hygiene prototype-contracts [--config <repo-relative-path>] [--strict|--report-only]" 474 ); 475 eprintln!(" cargo xtask source-lock --consumer-root <absolute-directory>"); 476 eprintln!( 477 " cargo xtask service-source-lock --mode <check|write|prepare> --service-root <absolute-directory> --source-archive <absolute-bundle>" 478 ); 479 eprintln!( 480 " cargo xtask service-release-artifacts --mode <check|write> --service-root <absolute-directory> --lib-root <absolute-directory> --input-root <absolute-directory> --output-root <absolute-directory> --target <rust-target> --source-date-epoch <seconds> --candidate-digest <sha256>" 481 ); 482 eprintln!( 483 " cargo xtask service-repro-install --plan <absolute-file> --source-root <absolute-directory> --root-preimage-root <absolute-directory> --predecessor-artifact-root <absolute-directory> --git-executable <absolute-file> --adapter-executable <absolute-file> --output <absolute-file>" 484 ); 485 eprintln!( 486 " cargo xtask source materialize --consumer-root <absolute-directory> --cache-root <absolute-directory> --mode <prefetch|offline>" 487 ); 488 eprintln!(" cargo xtask source archive-verify --archive <bundle> --sha256 <digest>"); 489 eprintln!( 490 " cargo xtask source archive-create --source-root <absolute-directory> --revision <full-sha> --output <absolute-bundle>" 491 ); 492 eprintln!( 493 " cargo xtask artifact --product sdk --target <target> --language <language> --mode <check|write> --consumer-root <absolute-directory> --source-root <absolute-directory> --output <relative-path> --source-date-epoch <seconds> --builder-id <id>" 494 ); 495 } 496 497 fn workspace_root_with_override(override_root: Option<&str>) -> PathBuf { 498 if let Some(raw) = override_root { 499 let trimmed = raw.trim(); 500 if !trimmed.is_empty() { 501 return PathBuf::from(trimmed); 502 } 503 } 504 let manifest_dir = Path::new(env!("CARGO_MANIFEST_DIR")); 505 let crates_dir = manifest_dir.parent().unwrap_or(manifest_dir); 506 let root = crates_dir.parent().unwrap_or(crates_dir); 507 root.to_path_buf() 508 } 509 510 fn workspace_root() -> PathBuf { 511 let override_root = env::var("RADROOTS_WORKSPACE_ROOT").ok(); 512 workspace_root_with_override(override_root.as_deref()) 513 } 514 515 fn validate_protocol_contracts() -> Result<(), String> { 516 use radroots_protocol::{capability, event, runtime, schema}; 517 518 capability::v1::validate_catalog(capability::v1::CATALOG).map_err(|error| error.to_string())?; 519 event::v1::validate_catalog(event::v1::CATALOG).map_err(|error| error.to_string())?; 520 event::v1::validate_trade_state_vocabulary(event::v1::TRADE_STATE_VOCABULARY) 521 .map_err(|error| error.to_string())?; 522 runtime::v1::validate_catalog(runtime::v1::CATALOG).map_err(|error| error.to_string())?; 523 schema::protocol_v1_registry() 524 .map(|_| ()) 525 .map_err(|error| error.to_string()) 526 } 527 528 fn validate_contract() -> Result<(), String> { 529 validate_protocol_contracts()?; 530 let root = workspace_root(); 531 artifact_admission::validate_contract(&root)?; 532 service_source_lock::validate_contract(&root)?; 533 // Retain historical qualification integrity separately from current requirements. 534 service_build_qualification::validate_contract(&root)?; 535 compiler_preparation::validate_contract(&root)?; 536 shared_protocol::validate_contract(&root)?; 537 service_release_artifacts::validate_contract(&root)?; 538 service_repro_install::validate_contract(&root)?; 539 dto_roots::check(&root)?; 540 generate::protocol::check(&root)?; 541 generate::data_notices::run("--check", &root)?; 542 contract::load_contract_bundle(&root) 543 .and_then(|bundle| contract::validate_contract_bundle(&bundle)) 544 .and_then(|_| contract::validate_canonical_event_boundary(&root)) 545 .and_then(|_| contract::validate_artifact_contracts(&root)) 546 } 547 548 #[cfg_attr(coverage_nightly, coverage(off))] 549 fn release_preflight() -> Result<(), String> { 550 let root = workspace_root(); 551 release_preflight_at(&root) 552 } 553 554 fn release_preflight_at(root: &Path) -> Result<(), String> { 555 use release_preflight::{LaneId, LaneState}; 556 557 release_preflight::execute_all(|lane| { 558 let result = match lane { 559 LaneId::Catalog => catalog::check(root), 560 LaneId::ServiceSourceLockContract => service_source_lock::validate_contract(root), 561 LaneId::ServiceBuildQualificationContract => { 562 service_build_qualification::validate_contract(root) 563 .and_then(|()| compiler_preparation::validate_contract(root)) 564 } 565 LaneId::ServiceReleaseArtifactsContract => { 566 service_release_artifacts::validate_contract(root) 567 .and_then(|()| service_repro_install::validate_contract(root)) 568 } 569 LaneId::PublicNativeGroup => build_control::group_plan( 570 root, 571 "public_native", 572 build_control::Operation::Check, 573 false, 574 ) 575 .map(|_| ()), 576 LaneId::PreviewGroup => { 577 build_control::group_plan(root, "preview", build_control::Operation::Check, false) 578 .map(|_| ()) 579 } 580 LaneId::ToolsGroup => { 581 build_control::group_plan(root, "tools", build_control::Operation::Check, false) 582 .map(|_| ()) 583 } 584 LaneId::DtoRoots => dto_roots::check(root), 585 LaneId::ProtocolFreshness => generate::protocol::check(root), 586 LaneId::ArtifactContracts => contract::validate_artifact_contracts(root), 587 LaneId::ReleaseContracts => advisory_snapshot::validate_decision(root) 588 .and_then(|_| contract::validate_release_preflight(root)), 589 }; 590 match result { 591 Ok(()) => LaneState::Pass, 592 Err(error) => { 593 eprintln!("release preflight {} failed: {error}", lane.as_str()); 594 LaneState::Failed 595 } 596 } 597 }) 598 .map(|_| ()) 599 .map_err(|error| error.to_string()) 600 } 601 602 #[cfg_attr(coverage_nightly, coverage(off))] 603 fn run_release(args: &[String]) -> Result<(), String> { 604 match args.first().map(String::as_str) { 605 Some("preflight") => release_preflight(), 606 Some("qualify-features") => release_qualification::run_feature_matrix(&workspace_root()), 607 Some("qualify-graph") => release_graph::run(&workspace_root()), 608 Some("qualify-api") => api_qualification::run(&workspace_root()), 609 Some("qualify-fuzz") => fuzz_qualification::run(&workspace_root()), 610 Some("qualify-portable") => portable_qualification::run(&workspace_root()), 611 Some("qualify-safety") => safety_qualification::run(&workspace_root()), 612 Some("qualify-supply-chain") => supply_chain_qualification::run(&workspace_root()), 613 Some("qualify-targets") => target_qualification::run(&workspace_root()), 614 _ => Err("unknown release subcommand".to_string()), 615 } 616 } 617 618 #[cfg_attr(coverage_nightly, coverage(off))] 619 fn run_contract(args: &[String]) -> Result<(), String> { 620 match args.first().map(String::as_str) { 621 Some("validate") => validate_contract(), 622 Some("event-contract-registry-v7") => match &args[1..] { 623 [] => contract::validate_event_contract_registry_v7_inventory(&workspace_root()), 624 [flag] if flag == "--write" => { 625 contract::write_event_contract_registry_v7_inventory(&workspace_root()) 626 } 627 _ => Err( 628 "event-contract-registry-v7 accepts no arguments or exactly --write".to_string(), 629 ), 630 }, 631 Some("knowledge-manifest") => { 632 if args.get(1).map(String::as_str) == Some("--write") { 633 contract::write_knowledge_contract_manifest(&workspace_root()) 634 } else { 635 contract::validate_knowledge_contract_manifest(&workspace_root()) 636 } 637 } 638 _ => Err("unknown contract subcommand".to_string()), 639 } 640 } 641 642 fn run(args: &[String]) -> Result<(), String> { 643 let cli = Cli::try_parse_from(std::iter::once("xtask").chain(args.iter().map(String::as_str))) 644 .map_err(|error| error.to_string())?; 645 match cli.command { 646 XtaskCommand::AdvisorySnapshotSelfTest => advisory_snapshot::self_test(), 647 XtaskCommand::AdvisorySnapshotFixtureScanner { mode } => { 648 advisory_snapshot::write_fixture_scanner_output(&mode) 649 } 650 XtaskCommand::Architecture => architecture::validate(&workspace_root()), 651 XtaskCommand::ArchitectureCi => { 652 catalog::check(&workspace_root())?; 653 architecture::validate_ci(&workspace_root())?; 654 validate_contract() 655 } 656 XtaskCommand::ArchitectureSourceExportCi => { 657 catalog::check_source_export(&workspace_root())?; 658 architecture::validate_ci(&workspace_root())?; 659 validate_contract() 660 } 661 XtaskCommand::BoundedProcessSelfTest => bounded_process::self_test(), 662 XtaskCommand::SafeArtifactIoSelfTest => { 663 safe_artifact_io::self_test()?; 664 release_preflight::self_test()?; 665 println!("safe artifact I/O self-test: ok"); 666 Ok(()) 667 } 668 XtaskCommand::CheckApiBoundaries => { 669 architecture::validate_api_boundaries(&workspace_root()) 670 } 671 XtaskCommand::CheckDependencyBoundaries => { 672 architecture::validate_dependency_boundaries(&workspace_root()) 673 } 674 XtaskCommand::Check { 675 group, 676 operation, 677 execute, 678 include_reserved, 679 } => { 680 let operation = match operation { 681 GroupOperation::Check => build_control::Operation::Check, 682 GroupOperation::Test => build_control::Operation::Test, 683 GroupOperation::Clippy => build_control::Operation::Clippy, 684 }; 685 let root = workspace_root(); 686 let plan = build_control::group_plan(&root, &group, operation, include_reserved)?; 687 if execute { 688 build_control::execute_group_plan(&root, &plan) 689 } else { 690 build_control::print_plan(&plan); 691 Ok(()) 692 } 693 } 694 XtaskCommand::Catalog { command } => match command { 695 CatalogCommand::Check => catalog::run(&["check".to_owned()], &workspace_root()), 696 CatalogCommand::Write => catalog::run(&["write".to_owned()], &workspace_root()), 697 }, 698 XtaskCommand::Contract { args } => run_contract(&args), 699 XtaskCommand::Consolidation { args } => consolidation::run(&args, &workspace_root()), 700 XtaskCommand::Coverage { args } => coverage::run(&args), 701 XtaskCommand::DtoRoots { args } => dto_roots::run(&args, &workspace_root()), 702 XtaskCommand::Generate { args } => generate::run(&args, &workspace_root()), 703 XtaskCommand::Hygiene { args } => hygiene::run(&args, &workspace_root()), 704 XtaskCommand::Release { args } => run_release(&args), 705 XtaskCommand::RshrStep298Gate { 706 step, 707 check_id, 708 source_revision, 709 source_tree, 710 candidate_digest, 711 platform, 712 execution_request_sha256, 713 } => rshr_202_step_298_gate::run(rshr_202_step_298_gate::Arguments { 714 step, 715 check_id, 716 source_revision, 717 source_tree, 718 candidate_digest, 719 platform, 720 execution_request_sha256, 721 }), 722 XtaskCommand::RshrStep298PlatformProbe => rshr_202_step_298_platform::run(), 723 XtaskCommand::RshrStep299Gate { 724 step, 725 check_id, 726 source_revision, 727 source_tree, 728 candidate_digest, 729 platform, 730 execution_request_sha256, 731 } => rshr_202_step_299_gate::run(rshr_202_step_299_gate::Arguments { 732 step, 733 check_id, 734 source_revision, 735 source_tree, 736 candidate_digest, 737 platform, 738 execution_request_sha256, 739 }), 740 XtaskCommand::RshrStep304Gate { 741 step, 742 check_id, 743 source_revision, 744 source_tree, 745 candidate_digest, 746 platform, 747 execution_request_sha256, 748 } => rshr_202_step_304_gate::run(rshr_202_step_304_gate::Arguments { 749 step, 750 check_id, 751 source_revision, 752 source_tree, 753 candidate_digest, 754 platform, 755 execution_request_sha256, 756 }), 757 XtaskCommand::RshrStep305Gate { 758 step, 759 check_id, 760 source_revision, 761 source_tree, 762 candidate_digest, 763 platform, 764 execution_request_sha256, 765 } => rshr_202_step_305_gate::run(rshr_202_step_305_gate::Arguments { 766 step, 767 check_id, 768 source_revision, 769 source_tree, 770 candidate_digest, 771 platform, 772 execution_request_sha256, 773 }), 774 XtaskCommand::RshrStep306Gate { 775 step, 776 check_id, 777 source_revision, 778 source_tree, 779 candidate_digest, 780 platform, 781 execution_request_sha256, 782 } => rshr_202_step_306_gate::run(rshr_202_step_306_gate::Arguments { 783 step, 784 check_id, 785 source_revision, 786 source_tree, 787 candidate_digest, 788 platform, 789 execution_request_sha256, 790 }), 791 XtaskCommand::SourceLock { consumer_root } => { 792 build_control::validate_consumer(&consumer_root).map(|_| ()) 793 } 794 XtaskCommand::ServiceSourceLock { 795 mode, 796 service_root, 797 source_archive, 798 } => service_source_lock_command::run( 799 match mode { 800 ServiceSourceLockMode::Check => service_source_lock_command::CommandMode::Check, 801 ServiceSourceLockMode::Write => service_source_lock_command::CommandMode::Write, 802 ServiceSourceLockMode::Prepare => service_source_lock_command::CommandMode::Prepare, 803 }, 804 &service_root, 805 &source_archive, 806 ), 807 XtaskCommand::ServiceReleaseArtifacts { 808 mode, 809 service_root, 810 lib_root, 811 input_root, 812 output_root, 813 target, 814 source_date_epoch, 815 candidate_digest, 816 } => service_release_artifacts::run(service_release_artifacts::Arguments { 817 mode: match mode { 818 ServiceReleaseArtifactMode::Check => service_release_artifacts::CommandMode::Check, 819 ServiceReleaseArtifactMode::Write => service_release_artifacts::CommandMode::Write, 820 }, 821 service_root: &service_root, 822 lib_root: &lib_root, 823 input_root: &input_root, 824 output_root: &output_root, 825 target: &target, 826 source_date_epoch, 827 candidate_digest: &candidate_digest, 828 }), 829 XtaskCommand::ServiceReproInstall { 830 plan, 831 source_root, 832 root_preimage_root, 833 predecessor_artifact_root, 834 git_executable, 835 adapter_executable, 836 output, 837 } => service_repro_install::run( 838 &workspace_root(), 839 service_repro_install::Arguments { 840 plan: &plan, 841 source_root: &source_root, 842 root_preimage_root: &root_preimage_root, 843 predecessor_artifact_root: &predecessor_artifact_root, 844 git_executable: &git_executable, 845 adapter_executable: &adapter_executable, 846 output: &output, 847 }, 848 ), 849 XtaskCommand::Source { command } => match command { 850 SourceCommand::Materialize { 851 consumer_root, 852 cache_root, 853 mode, 854 } => build_control::materialize( 855 &consumer_root, 856 &cache_root, 857 matches!(mode, SourceMode::Offline), 858 ) 859 .map(|path| { 860 println!("{}", path.display()); 861 }), 862 SourceCommand::ArchiveVerify { archive, sha256 } => { 863 build_control::verify_source_archive(&archive, &sha256) 864 } 865 SourceCommand::ArchiveCreate { 866 source_root, 867 revision, 868 output, 869 } => build_control::create_source_archive(&source_root, &revision, &output).map( 870 |digest| { 871 println!("{digest}"); 872 }, 873 ), 874 }, 875 XtaskCommand::Artifact { 876 product, 877 target, 878 language, 879 mode, 880 consumer_root, 881 source_root, 882 output, 883 source_date_epoch, 884 builder_id, 885 features, 886 } => { 887 let product = product.as_str(); 888 let target = target.as_str(); 889 let language = language.as_str(); 890 let mode = match mode { 891 ArtifactMode::Check => build_control::Mode::Check, 892 ArtifactMode::Write => build_control::Mode::Write, 893 }; 894 build_control::validate_generation_roots( 895 product, 896 target, 897 language, 898 &consumer_root, 899 &source_root, 900 )?; 901 if product == "sdk" { 902 sdk_generation::artifact(&source_root, &consumer_root, target, language, mode)?; 903 } 904 build_control::artifact( 905 product, 906 target, 907 language, 908 mode, 909 &consumer_root, 910 &source_root, 911 &output, 912 source_date_epoch, 913 &builder_id, 914 &features, 915 ) 916 } 917 } 918 } 919 920 fn main_with_args(args: Vec<String>) -> ExitCode { 921 if args.is_empty() { 922 usage(); 923 return ExitCode::from(2); 924 } 925 match run(&args) { 926 Ok(()) => ExitCode::SUCCESS, 927 Err(err) => { 928 eprintln!("{err}"); 929 usage(); 930 ExitCode::from(2) 931 } 932 } 933 } 934 935 #[cfg_attr(coverage_nightly, coverage(off))] 936 fn main() -> ExitCode { 937 main_with_args(env::args().skip(1).collect()) 938 } 939 940 #[cfg(test)] 941 mod tests { 942 use super::*; 943 use std::fs; 944 use std::sync::{Mutex, MutexGuard, OnceLock}; 945 use std::time::{SystemTime, UNIX_EPOCH}; 946 947 fn workspace_lock() -> &'static Mutex<()> { 948 static LOCK: OnceLock<Mutex<()>> = OnceLock::new(); 949 LOCK.get_or_init(|| Mutex::new(())) 950 } 951 952 fn lock_workspace() -> MutexGuard<'static, ()> { 953 match workspace_lock().lock() { 954 Ok(guard) => guard, 955 Err(poison) => poison.into_inner(), 956 } 957 } 958 959 fn unique_temp_dir(prefix: &str) -> PathBuf { 960 let ns = SystemTime::now() 961 .duration_since(UNIX_EPOCH) 962 .expect("system time") 963 .as_nanos(); 964 std::env::temp_dir().join(format!("radroots_xtask_main_{prefix}_{ns}")) 965 } 966 967 #[test] 968 fn workspace_root_resolves() { 969 let root = workspace_root(); 970 assert!(root.join("Cargo.toml").exists()); 971 } 972 973 #[test] 974 fn workspace_root_override_takes_precedence() { 975 let root = workspace_root_with_override(Some("/tmp/radroots-test-root")); 976 assert_eq!(root, PathBuf::from("/tmp/radroots-test-root")); 977 978 let fallback = workspace_root_with_override(Some(" ")); 979 assert!(fallback.join("Cargo.toml").exists()); 980 981 let default_root = workspace_root_with_override(None); 982 assert!(default_root.join("Cargo.toml").exists()); 983 } 984 985 #[test] 986 fn typed_build_control_cli_requires_explicit_modes_and_known_values() { 987 assert!(Cli::try_parse_from(["xtask", "bounded-process-self-test"]).is_ok()); 988 assert!(Cli::try_parse_from(["xtask", "safe-artifact-io-self-test"]).is_ok()); 989 990 let source_args = [ 991 "xtask", 992 "source", 993 "materialize", 994 "--consumer-root", 995 "/tmp/consumer", 996 "--cache-root", 997 "/tmp/cache", 998 ]; 999 assert!(Cli::try_parse_from(source_args).is_err()); 1000 assert!(Cli::try_parse_from(source_args.into_iter().chain(["--mode", "prefetch"])).is_ok()); 1001 1002 assert!( 1003 Cli::try_parse_from([ 1004 "xtask", 1005 "service-source-lock", 1006 "--mode", 1007 "check", 1008 "--service-root", 1009 "/tmp/service", 1010 ]) 1011 .is_err() 1012 ); 1013 for mode in ["write", "prepare"] { 1014 assert!( 1015 Cli::try_parse_from([ 1016 "xtask", 1017 "service-source-lock", 1018 "--mode", 1019 mode, 1020 "--service-root", 1021 "/tmp/service", 1022 "--source-archive", 1023 "/tmp/lib.bundle", 1024 ]) 1025 .is_ok() 1026 ); 1027 } 1028 assert!( 1029 Cli::try_parse_from([ 1030 "xtask", 1031 "service-release-artifacts", 1032 "--mode", 1033 "write", 1034 "--service-root", 1035 "/tmp/service", 1036 "--lib-root", 1037 "/tmp/lib", 1038 "--input-root", 1039 "/tmp/input", 1040 "--output-root", 1041 "/tmp/output", 1042 "--target", 1043 "x86_64-unknown-linux-gnu", 1044 ]) 1045 .is_err() 1046 ); 1047 assert!( 1048 Cli::try_parse_from([ 1049 "xtask", 1050 "service-release-artifacts", 1051 "--mode", 1052 "check", 1053 "--service-root", 1054 "/tmp/service", 1055 "--lib-root", 1056 "/tmp/lib", 1057 "--input-root", 1058 "/tmp/input", 1059 "--output-root", 1060 "/tmp/output", 1061 "--target", 1062 "x86_64-unknown-linux-gnu", 1063 "--source-date-epoch", 1064 "1", 1065 "--candidate-digest", 1066 "1111111111111111111111111111111111111111111111111111111111111111", 1067 ]) 1068 .is_ok() 1069 ); 1070 assert!( 1071 Cli::try_parse_from([ 1072 "xtask", 1073 "service-repro-install", 1074 "--plan", 1075 "/tmp/plan.json", 1076 "--source-root", 1077 "/tmp/source", 1078 "--root-preimage-root", 1079 "/tmp/root", 1080 "--predecessor-artifact-root", 1081 "/tmp/predecessor", 1082 "--git-executable", 1083 "/usr/bin/git", 1084 "--adapter-executable", 1085 "/tmp/adapter", 1086 "--output", 1087 "/tmp/result.json", 1088 ]) 1089 .is_ok() 1090 ); 1091 1092 assert!( 1093 Cli::try_parse_from([ 1094 "xtask", 1095 "artifact", 1096 "--product", 1097 "unknown", 1098 "--target", 1099 "wasm", 1100 "--language", 1101 "javascript", 1102 "--mode", 1103 "check", 1104 "--consumer-root", 1105 "/tmp/consumer", 1106 "--source-root", 1107 "/tmp/source", 1108 "--output", 1109 "generated/manifest.json", 1110 "--source-date-epoch", 1111 "1", 1112 "--builder-id", 1113 "fixture", 1114 ]) 1115 .is_err() 1116 ); 1117 } 1118 1119 #[test] 1120 fn artifact_cli_values_preserve_every_governed_identifier() { 1121 assert!(ArtifactProduct::from_str("mobile", false).is_err()); 1122 assert!(ArtifactTarget::from_str("ios", false).is_err()); 1123 assert!(ArtifactTarget::from_str("android", false).is_err()); 1124 assert_eq!([ArtifactProduct::Sdk.as_str()], ["sdk"]); 1125 assert_eq!( 1126 [ 1127 ArtifactTarget::Typescript.as_str(), 1128 ArtifactTarget::Wasm.as_str(), 1129 ArtifactTarget::Ffi.as_str(), 1130 ArtifactTarget::Linux.as_str(), 1131 ArtifactTarget::Macos.as_str(), 1132 ArtifactTarget::Windows.as_str(), 1133 ], 1134 ["typescript", "wasm", "ffi", "linux", "macos", "windows",] 1135 ); 1136 assert_eq!( 1137 [ 1138 ArtifactLanguage::Typescript.as_str(), 1139 ArtifactLanguage::Swift.as_str(), 1140 ArtifactLanguage::Kotlin.as_str(), 1141 ArtifactLanguage::Javascript.as_str(), 1142 ], 1143 ["typescript", "swift", "kotlin", "javascript"] 1144 ); 1145 } 1146 1147 #[test] 1148 fn run_release_and_dispatchers_cover_error_paths() { 1149 let unknown_release = 1150 run_release(&["unknown".to_string()]).expect_err("unknown release subcommand"); 1151 assert!(unknown_release.contains("unknown release subcommand")); 1152 1153 let unknown_contract = 1154 run_contract(&["unknown".to_string()]).expect_err("unknown contract subcommand"); 1155 assert!(unknown_contract.contains("unknown contract subcommand")); 1156 let invalid_registry = run_contract(&[ 1157 "event-contract-registry-v7".to_string(), 1158 "--invalid".to_string(), 1159 ]) 1160 .expect_err("invalid registry-v7 mode"); 1161 assert!(invalid_registry.contains("exactly --write")); 1162 let unknown_root = run(&["unknown".to_string()]).expect_err("unknown command"); 1163 assert!(unknown_root.contains("unrecognized subcommand")); 1164 1165 run(&["architecture".to_string()]).expect("architecture ledger validates"); 1166 1167 let invalid_dto_roots = 1168 run(&["dto-roots".to_string()]).expect_err("dto-roots requires an explicit mode"); 1169 assert!(invalid_dto_roots.contains("--check|--write")); 1170 let invalid_generate = 1171 run(&["generate".to_string()]).expect_err("generate requires a target and mode"); 1172 assert_eq!( 1173 invalid_generate, 1174 "usage: cargo xtask generate protocol|data-notices --check|--write" 1175 ); 1176 1177 let removed_sdk = run(&["sdk".to_string(), "validate".to_string()]) 1178 .expect_err("removed sdk command namespace"); 1179 assert!(removed_sdk.contains("unrecognized subcommand")); 1180 } 1181 1182 #[test] 1183 fn release_preflight_exhausts_the_closed_lane_inventory() { 1184 let workspace = tempfile::TempDir::new().expect("create empty workspace"); 1185 let error = release_preflight_at(workspace.path()) 1186 .expect_err("missing required inputs must fail closed"); 1187 assert_eq!(error, "release preflight required lanes did not all pass"); 1188 } 1189 1190 #[test] 1191 fn lock_workspace_recovers_from_poisoned_mutex() { 1192 let handle = std::thread::spawn(|| { 1193 let _guard = workspace_lock().lock().expect("lock workspace"); 1194 panic!("poison workspace lock"); 1195 }); 1196 assert!(handle.join().is_err()); 1197 1198 let _guard = lock_workspace(); 1199 } 1200 1201 #[test] 1202 fn contract_and_coverage_dispatchers_execute() { 1203 let _guard = lock_workspace(); 1204 let out_dir = unique_temp_dir("coverage_dispatch"); 1205 fs::create_dir_all(&out_dir).expect("create out dir"); 1206 1207 run_contract(&["validate".to_string()]).expect("validate contract"); 1208 run(&["dto-roots".to_string(), "--check".to_string()]) 1209 .expect("validate DTO root freshness"); 1210 run(&[ 1211 "generate".to_string(), 1212 "protocol".to_string(), 1213 "--check".to_string(), 1214 ]) 1215 .expect("validate protocol DTO inventory freshness"); 1216 coverage::run(&["help".to_string()]).expect("coverage help"); 1217 coverage::run(&["required-crates".to_string()]).expect("coverage required crates"); 1218 coverage::run(&["workspace-crates".to_string()]).expect("coverage workspace crates"); 1219 1220 let summary_path = out_dir.join("summary.json"); 1221 let lcov_path = out_dir.join("coverage.info"); 1222 let gate_out = out_dir.join("gate-report.json"); 1223 fs::write( 1224 &summary_path, 1225 r#"{"data":[{"totals":{"functions":{"percent":100.0},"lines":{"percent":100.0},"regions":{"percent":100.0}}}]}"#, 1226 ) 1227 .expect("write summary"); 1228 fs::write(&lcov_path, "DA:1,1\nBRDA:1,0,0,1\n").expect("write lcov"); 1229 coverage::run(&[ 1230 "report".to_string(), 1231 "--scope".to_string(), 1232 "main-test".to_string(), 1233 "--summary".to_string(), 1234 summary_path.display().to_string(), 1235 "--lcov".to_string(), 1236 lcov_path.display().to_string(), 1237 "--out".to_string(), 1238 gate_out.display().to_string(), 1239 "--policy-gate".to_string(), 1240 ]) 1241 .expect("coverage report"); 1242 1243 run(&["coverage".to_string(), "help".to_string()]).expect("root run coverage"); 1244 run(&["hygiene".to_string(), "forbidden-identifiers".to_string()]) 1245 .expect("hygiene forbidden identifiers"); 1246 run(&["hygiene".to_string(), "prototype-contracts".to_string()]) 1247 .expect("report prototype contracts"); 1248 1249 let _ = fs::remove_dir_all(out_dir); 1250 } 1251 1252 #[test] 1253 fn usage_and_main_entrypoints_execute() { 1254 usage(); 1255 let empty_code = main_with_args(Vec::new()); 1256 assert_eq!(empty_code, ExitCode::from(2)); 1257 let success_code = main_with_args(vec!["coverage".to_string(), "help".to_string()]); 1258 assert_eq!(success_code, ExitCode::SUCCESS); 1259 let failure_code = main_with_args(vec!["unknown".to_string()]); 1260 assert_eq!(failure_code, ExitCode::from(2)); 1261 let _ = main(); 1262 } 1263 1264 #[test] 1265 fn run_contract_dispatches_validate_command() { 1266 let _guard = lock_workspace(); 1267 validate_protocol_contracts().expect("final protocol contract catalogs"); 1268 run_contract(&["validate".to_string()]).expect("contract validate"); 1269 run_contract(&["event-contract-registry-v7".to_string()]) 1270 .expect("contract registry-v7 inventory"); 1271 run_contract(&["knowledge-manifest".to_string()]).expect("contract knowledge manifest"); 1272 } 1273 }