From 850c82d0bbbd42ee7f264107d7821c8b344e0f92 Mon Sep 17 00:00:00 2001 From: Adam Date: Sat, 1 Aug 2026 18:40:06 -0400 Subject: [PATCH 1/5] fix(sccm): map server intake artifact requests --- .../src/sccm/server/windows/intake.rs | 43 +++++--- .../tests/sccm_server_intake.rs | 102 +++++++++++++++++- 2 files changed, 123 insertions(+), 22 deletions(-) diff --git a/crates/cmtraceopen-parser/src/sccm/server/windows/intake.rs b/crates/cmtraceopen-parser/src/sccm/server/windows/intake.rs index 61a654449..a1be78a7f 100644 --- a/crates/cmtraceopen-parser/src/sccm/server/windows/intake.rs +++ b/crates/cmtraceopen-parser/src/sccm/server/windows/intake.rs @@ -6,8 +6,8 @@ use serde_json::Value; use thiserror::Error; use crate::sccm::{ - normalize_ccm_artifact, SccmArtifact, SccmArtifactFamily, SccmArtifactRequest, - SccmCoverageState, SccmEvidence, SccmFinding, SccmRole, SccmRotation, + classify_artifact_name, normalize_ccm_artifact, SccmArtifact, SccmArtifactFamily, + SccmArtifactRequest, SccmCoverageState, SccmEvidence, SccmFinding, SccmRole, SccmRotation, }; use super::catalog::{classify_declared_server_source, expected_family, SccmServerSourceKind}; @@ -896,22 +896,31 @@ fn request_for_gap( { return None; } - let reason = match artifact.state { - SccmCoverageState::Absent => "source was absent; role outcome remains unknown", - SccmCoverageState::AccessDenied => "source access was denied; role outcome remains unknown", - SccmCoverageState::Capped => "source was capped; terminal role evidence is incomplete", - SccmCoverageState::ParseFailed => { - "source parsing failed; terminal role evidence is unavailable" - } - _ => return None, - }; + if !matches!( + artifact.state, + SccmCoverageState::Absent + | SccmCoverageState::AccessDenied + | SccmCoverageState::Capped + | SccmCoverageState::ParseFailed + ) { + return None; + } + + let classified = classify_artifact_name( + artifact.original_basename.as_deref()?, + artifact.producer_role.clone(), + ); + if !classified.uses_ccm_records + || !classified.supported_for_diagnosis + || classified.family != artifact.family + { + return None; + } + Some(SccmArtifactRequest { - logical_id: artifact.source_id.clone(), - role: artifact - .workflow_subject_role - .clone() - .unwrap_or_else(|| artifact.producer_role.clone()), - reason: reason.to_owned(), + logical_id: classified.logical_name, + role: classified.role, + reason: format!("Collect the complete {} file.", classified.basename), }) } diff --git a/crates/cmtraceopen-parser/tests/sccm_server_intake.rs b/crates/cmtraceopen-parser/tests/sccm_server_intake.rs index da70b78e4..baac99b7b 100644 --- a/crates/cmtraceopen-parser/tests/sccm_server_intake.rs +++ b/crates/cmtraceopen-parser/tests/sccm_server_intake.rs @@ -1,7 +1,11 @@ +use cmtraceopen_parser::models::log_entry::Severity; use cmtraceopen_parser::sccm::server::windows::{ assess_server_intake, SccmServerArtifactPayload, SccmServerIntakeError, }; -use cmtraceopen_parser::sccm::{SccmCoverageState, SccmRole, SccmRotation}; +use cmtraceopen_parser::sccm::{ + SccmConfidence, SccmCoverageState, SccmFinding, SccmFindingBuilder, SccmFindingClass, + SccmFindingCoverageGap, SccmPhase, SccmRole, SccmRotation, +}; use serde_json::{json, Value}; use std::path::{Path, PathBuf}; @@ -74,6 +78,39 @@ fn artifact_json<'a>(assessment: &'a Value, artifact_id: &str) -> &'a Value { .expect("artifact is present") } +fn assert_request_passes_finding_boundaries( + scenario: &str, + assessment: &cmtraceopen_parser::sccm::server::windows::SccmServerIntakeAssessment, +) { + let request = assessment + .next_artifact_requests + .first() + .unwrap_or_else(|| panic!("{scenario} emits one bounded request")); + let artifact = assessment + .artifacts + .first() + .unwrap_or_else(|| panic!("{scenario} retains its coverage artifact")); + let finding = SccmFindingBuilder::new(format!("server-intake-{scenario}")) + .class(SccmFindingClass::InsufficientEvidence) + .phase(SccmPhase::Unknown("serverIntake".to_owned())) + .role(request.role.clone()) + .severity(Severity::Warning) + .confidence(SccmConfidence::Low) + .coverage_gap(SccmFindingCoverageGap { + artifact_id: artifact.artifact_id.clone(), + role: request.role.clone(), + coverage: artifact.state.clone(), + }) + .next_artifact(request.clone()) + .build() + .unwrap_or_else(|error| panic!("{scenario} request must validate: {error:?}")); + + let serialized = serde_json::to_value(&finding) + .unwrap_or_else(|error| panic!("{scenario} finding must serialize: {error}")); + serde_json::from_value::(serialized) + .unwrap_or_else(|error| panic!("{scenario} finding must deserialize: {error}")); +} + #[test] fn server_intake_normalizes_role_coverage_and_logical_records() { let (complete_manifest, complete_payloads) = load_bundle("complete-multi-role"); @@ -137,10 +174,7 @@ fn server_intake_normalizes_role_coverage_and_logical_records() { assert!(absent.evidence.is_empty()); assert!(absent.findings.is_empty()); assert_eq!(absent.next_artifact_requests.len(), 1); - assert_eq!( - absent.next_artifact_requests[0].logical_id, - "server-dp-distribution" - ); + assert_eq!(absent.next_artifact_requests[0].logical_id, "distmgr"); let (unsorted_manifest, unsorted_payloads) = load_bundle("unsorted-manifest"); let unsorted = @@ -163,6 +197,64 @@ fn server_intake_normalizes_role_coverage_and_logical_records() { ); } +#[test] +fn server_intake_gap_requests_use_exact_shared_catalog_artifacts() { + let cases = [ + ( + "absent-dp", + "distmgr", + SccmRole::SiteServer, + "Collect the complete distmgr.log file.", + ), + ( + "access-denied-mp", + "mpGetPolicy", + SccmRole::ManagementPoint, + "Collect the complete MP_GetPolicy.log file.", + ), + ( + "capped-sup", + "wsyncmgr", + SccmRole::SiteServer, + "Collect the complete wsyncmgr.log file.", + ), + ]; + + for (scenario, logical_id, role, reason) in cases { + let (manifest, payloads) = load_bundle(scenario); + let assessment = assess_server_intake(&manifest, &payloads) + .unwrap_or_else(|error| panic!("{scenario} should be assessed: {error}")); + + assert_request_passes_finding_boundaries(scenario, &assessment); + assert_eq!(assessment.next_artifact_requests.len(), 1, "{scenario}"); + let request = &assessment.next_artifact_requests[0]; + assert_eq!(request.logical_id, logical_id, "{scenario}"); + assert_eq!(request.role, role, "{scenario}"); + assert_eq!(request.reason, reason, "{scenario}"); + } +} + +#[test] +fn server_intake_does_not_request_unknown_or_non_ccm_sources() { + let (iis_manifest, iis_payloads) = load_bundle("skipped-iis"); + let mut denied_iis = manifest_value(&iis_manifest); + denied_iis["artifacts"][0]["captureState"] = Value::String("accessDenied".to_owned()); + let iis = assess_server_intake(&serialize_manifest(&denied_iis), &iis_payloads) + .expect("non-CCM coverage remains assessable"); + assert!( + iis.next_artifact_requests.is_empty(), + "a non-CCM group has no shared catalog artifact request" + ); + + let (unknown_manifest, unknown_payloads) = load_bundle("unsupported-db-supplement"); + let unknown = assess_server_intake(&unknown_manifest, &unknown_payloads) + .expect("unknown coverage remains assessable"); + assert!( + unknown.next_artifact_requests.is_empty(), + "an unknown source has no shared catalog artifact request" + ); +} + #[test] fn server_intake_rejects_identity_bearing_public_inputs() { assert_unsafe_mutation_is_rejected("complete-multi-role", "realuser", |manifest, _payloads| { From 58d0feb6d2fdbd5e53908d88b7f2f264c332bffa Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Sat, 1 Aug 2026 23:12:37 +0000 Subject: [PATCH 2/5] fix(lint): collapse match guards to satisfy clippy::collapsible_match --- ...er_hierarchy_and_replication_fixture_contract.rs | 13 ++++++------- ...r_provider_and_admin_service_fixture_contract.rs | 13 ++++++------- 2 files changed, 12 insertions(+), 14 deletions(-) diff --git a/crates/cmtraceopen-parser/tests/sccm_server_hierarchy_and_replication_fixture_contract.rs b/crates/cmtraceopen-parser/tests/sccm_server_hierarchy_and_replication_fixture_contract.rs index 31d33c0c1..c6642b2be 100644 --- a/crates/cmtraceopen-parser/tests/sccm_server_hierarchy_and_replication_fixture_contract.rs +++ b/crates/cmtraceopen-parser/tests/sccm_server_hierarchy_and_replication_fixture_contract.rs @@ -1488,17 +1488,16 @@ fn identity_and_schema_failures(scenario: &str, manifest: &Value, expected: &Val } } } - Some("absent" | "accessDenied" | "skipped" | "unsupported") => { + Some("absent" | "accessDenied" | "skipped" | "unsupported") if artifact.get("relativePath").is_some() || artifact.get("bytesCopied").is_some() || artifact.get("encoding").is_some() || artifact.get("collectionLimit").is_some() - || artifact["rotation"].get("fragmentComplete").is_some() - { - failures.push(format!( - "{artifact_id}: nonphysical state invents physical provenance" - )); - } + || artifact["rotation"].get("fragmentComplete").is_some() => + { + failures.push(format!( + "{artifact_id}: nonphysical state invents physical provenance" + )); } _ => {} } diff --git a/crates/cmtraceopen-parser/tests/sccm_server_provider_and_admin_service_fixture_contract.rs b/crates/cmtraceopen-parser/tests/sccm_server_provider_and_admin_service_fixture_contract.rs index 8def5837c..83e219b28 100644 --- a/crates/cmtraceopen-parser/tests/sccm_server_provider_and_admin_service_fixture_contract.rs +++ b/crates/cmtraceopen-parser/tests/sccm_server_provider_and_admin_service_fixture_contract.rs @@ -977,17 +977,16 @@ fn schema_failures(scenario: &str, manifest: &Value, expected: &Value) -> Vec { + Some("absent" | "accessDenied" | "skipped" | "unsupported") if artifact.get("relativePath").is_some() || artifact.get("bytesCopied").is_some() || artifact.get("encoding").is_some() || artifact.get("collectionLimit").is_some() - || artifact["rotation"].get("fragmentComplete").is_some() - { - failures.push(format!( - "{artifact_id}: nonphysical coverage invents file provenance" - )); - } + || artifact["rotation"].get("fragmentComplete").is_some() => + { + failures.push(format!( + "{artifact_id}: nonphysical coverage invents file provenance" + )); } _ => {} } From 32dad74dcd96564939d8d1aafa2209aaf620bba4 Mon Sep 17 00:00:00 2001 From: Adam Date: Sat, 1 Aug 2026 19:17:58 -0400 Subject: [PATCH 3/5] Revert "fix(lint): collapse match guards to satisfy clippy::collapsible_match" This reverts commit 58d0feb6d2fdbd5e53908d88b7f2f264c332bffa. --- ...er_hierarchy_and_replication_fixture_contract.rs | 13 +++++++------ ...r_provider_and_admin_service_fixture_contract.rs | 13 +++++++------ 2 files changed, 14 insertions(+), 12 deletions(-) diff --git a/crates/cmtraceopen-parser/tests/sccm_server_hierarchy_and_replication_fixture_contract.rs b/crates/cmtraceopen-parser/tests/sccm_server_hierarchy_and_replication_fixture_contract.rs index c6642b2be..31d33c0c1 100644 --- a/crates/cmtraceopen-parser/tests/sccm_server_hierarchy_and_replication_fixture_contract.rs +++ b/crates/cmtraceopen-parser/tests/sccm_server_hierarchy_and_replication_fixture_contract.rs @@ -1488,16 +1488,17 @@ fn identity_and_schema_failures(scenario: &str, manifest: &Value, expected: &Val } } } - Some("absent" | "accessDenied" | "skipped" | "unsupported") + Some("absent" | "accessDenied" | "skipped" | "unsupported") => { if artifact.get("relativePath").is_some() || artifact.get("bytesCopied").is_some() || artifact.get("encoding").is_some() || artifact.get("collectionLimit").is_some() - || artifact["rotation"].get("fragmentComplete").is_some() => - { - failures.push(format!( - "{artifact_id}: nonphysical state invents physical provenance" - )); + || artifact["rotation"].get("fragmentComplete").is_some() + { + failures.push(format!( + "{artifact_id}: nonphysical state invents physical provenance" + )); + } } _ => {} } diff --git a/crates/cmtraceopen-parser/tests/sccm_server_provider_and_admin_service_fixture_contract.rs b/crates/cmtraceopen-parser/tests/sccm_server_provider_and_admin_service_fixture_contract.rs index 83e219b28..8def5837c 100644 --- a/crates/cmtraceopen-parser/tests/sccm_server_provider_and_admin_service_fixture_contract.rs +++ b/crates/cmtraceopen-parser/tests/sccm_server_provider_and_admin_service_fixture_contract.rs @@ -977,16 +977,17 @@ fn schema_failures(scenario: &str, manifest: &Value, expected: &Value) -> Vec { if artifact.get("relativePath").is_some() || artifact.get("bytesCopied").is_some() || artifact.get("encoding").is_some() || artifact.get("collectionLimit").is_some() - || artifact["rotation"].get("fragmentComplete").is_some() => - { - failures.push(format!( - "{artifact_id}: nonphysical coverage invents file provenance" - )); + || artifact["rotation"].get("fragmentComplete").is_some() + { + failures.push(format!( + "{artifact_id}: nonphysical coverage invents file provenance" + )); + } } _ => {} } From 4fe4296f6a66f02a5089ddb6d6a9e34c588c85c0 Mon Sep 17 00:00:00 2001 From: Adam Date: Sat, 1 Aug 2026 19:24:19 -0400 Subject: [PATCH 4/5] test(sccm): assert server request round trip (#335) --- crates/cmtraceopen-parser/tests/sccm_server_intake.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/crates/cmtraceopen-parser/tests/sccm_server_intake.rs b/crates/cmtraceopen-parser/tests/sccm_server_intake.rs index baac99b7b..c068a7087 100644 --- a/crates/cmtraceopen-parser/tests/sccm_server_intake.rs +++ b/crates/cmtraceopen-parser/tests/sccm_server_intake.rs @@ -107,8 +107,12 @@ fn assert_request_passes_finding_boundaries( let serialized = serde_json::to_value(&finding) .unwrap_or_else(|error| panic!("{scenario} finding must serialize: {error}")); - serde_json::from_value::(serialized) + let deserialized = serde_json::from_value::(serialized) .unwrap_or_else(|error| panic!("{scenario} finding must deserialize: {error}")); + assert_eq!( + deserialized, finding, + "{scenario} request and coverage data must survive the JSON boundary" + ); } #[test] From 46a7d06efd66cf989756c5a9989e896f78f70079 Mon Sep 17 00:00:00 2001 From: Adam Date: Sat, 1 Aug 2026 19:32:37 -0400 Subject: [PATCH 5/5] fix(sccm): scope server source requests to topology (#335) --- .../src/sccm/server/windows/intake.rs | 14 +++++- .../tests/sccm_server_intake.rs | 44 +++++++++++++++++++ 2 files changed, 57 insertions(+), 1 deletion(-) diff --git a/crates/cmtraceopen-parser/src/sccm/server/windows/intake.rs b/crates/cmtraceopen-parser/src/sccm/server/windows/intake.rs index a1be78a7f..f69ad168c 100644 --- a/crates/cmtraceopen-parser/src/sccm/server/windows/intake.rs +++ b/crates/cmtraceopen-parser/src/sccm/server/windows/intake.rs @@ -873,9 +873,16 @@ fn normalize_collected_utc(value: &str) -> Result .to_rfc3339_opts(SecondsFormat::Secs, true)) } -fn logical_source_key(artifact: &SccmServerArtifactAssessment) -> (String, String, String) { +fn logical_source_key( + artifact: &SccmServerArtifactAssessment, +) -> (String, String, String, String, String) { ( role_sort_key(&artifact.producer_role).to_owned(), + artifact + .producer_host_handle + .as_deref() + .unwrap_or_default() + .to_owned(), artifact.source_id.clone(), artifact .workflow_subject_role @@ -883,6 +890,11 @@ fn logical_source_key(artifact: &SccmServerArtifactAssessment) -> (String, Strin .map(role_sort_key) .unwrap_or_default() .to_owned(), + artifact + .workflow_subject_handle + .as_deref() + .unwrap_or_default() + .to_owned(), ) } diff --git a/crates/cmtraceopen-parser/tests/sccm_server_intake.rs b/crates/cmtraceopen-parser/tests/sccm_server_intake.rs index c068a7087..bf65aaeff 100644 --- a/crates/cmtraceopen-parser/tests/sccm_server_intake.rs +++ b/crates/cmtraceopen-parser/tests/sccm_server_intake.rs @@ -665,6 +665,50 @@ fn server_intake_suppresses_absent_default_request_when_configured_source_is_usa ); } +#[test] +fn server_intake_does_not_suppress_default_request_across_producer_hosts() { + let (configured_manifest, configured_payloads) = load_bundle("configured-nondefault-path"); + let mut combined = manifest_value(&configured_manifest); + let (absent_manifest, _absent_payloads) = load_bundle("access-denied-mp"); + let mut absent = manifest_value(&absent_manifest)["artifacts"][0].clone(); + absent["producerHostHandle"] = Value::String("synthetic:host:site-01".to_owned()); + absent["captureState"] = Value::String("absent".to_owned()); + absent["configuredPathProvenance"]["state"] = Value::String("defaultCandidate".to_owned()); + combined["artifacts"] + .as_array_mut() + .expect("artifacts are an array") + .push(absent); + + let assessment = assess_server_intake(&serialize_manifest(&combined), &configured_payloads) + .expect("distinct-host configured and default candidates are assessed together"); + assert_eq!(assessment.next_artifact_requests.len(), 1); + assert_eq!( + assessment.next_artifact_requests[0].logical_id, + "mpGetPolicy" + ); +} + +#[test] +fn server_intake_does_not_suppress_default_request_across_workflow_subjects() { + let (captured_manifest, captured_payloads) = load_bundle("complete-multi-role"); + let mut combined = manifest_value(&captured_manifest); + let (absent_manifest, _absent_payloads) = load_bundle("absent-dp"); + let mut absent = manifest_value(&absent_manifest)["artifacts"][0].clone(); + absent["workflowSubject"] = json!({ + "role": "distributionPoint", + "instanceHandle": "synthetic:subject:dp-02", + }); + combined["artifacts"] + .as_array_mut() + .expect("artifacts are an array") + .push(absent); + + let assessment = assess_server_intake(&serialize_manifest(&combined), &captured_payloads) + .expect("distinct-subject configured and default candidates are assessed together"); + assert_eq!(assessment.next_artifact_requests.len(), 1); + assert_eq!(assessment.next_artifact_requests[0].logical_id, "distmgr"); +} + #[test] fn server_intake_exercises_role_state_rotation_and_privacy_matrix() { let cases = [