diff --git a/crates/cmtraceopen-parser/src/sccm/server/windows/intake.rs b/crates/cmtraceopen-parser/src/sccm/server/windows/intake.rs index 61a654449..f69ad168c 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}; @@ -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(), ) } @@ -896,22 +908,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..bf65aaeff 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,43 @@ 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}")); + 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] fn server_intake_normalizes_role_coverage_and_logical_records() { let (complete_manifest, complete_payloads) = load_bundle("complete-multi-role"); @@ -137,10 +178,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 +201,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| { @@ -569,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 = [