Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
57 changes: 39 additions & 18 deletions crates/cmtraceopen-parser/src/sccm/server/windows/intake.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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};
Expand Down Expand Up @@ -873,16 +873,28 @@ fn normalize_collected_utc(value: &str) -> Result<String, SccmServerIntakeError>
.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
.as_ref()
.map(role_sort_key)
.unwrap_or_default()
.to_owned(),
artifact
.workflow_subject_handle
.as_deref()
.unwrap_or_default()
.to_owned(),
)
}

Expand All @@ -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),
})
}

Expand Down
150 changes: 145 additions & 5 deletions crates/cmtraceopen-parser/tests/sccm_server_intake.rs
Original file line number Diff line number Diff line change
@@ -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};

Expand Down Expand Up @@ -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::<SccmFinding>(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");
Expand Down Expand Up @@ -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 =
Expand All @@ -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| {
Expand Down Expand Up @@ -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 = [
Expand Down