use super::status_analytics::*;
use super::status_drift_intel::*;
use super::status_drift_intel2::*;
use super::status_fleet_insight::*;
use super::status_maturity::*;
use super::status_operational_ext::*;
use super::status_operational_ext2::*;
use super::status_quality::*;
use super::status_resilience::*;
use super::status_resource_intel::*;
use super::status_security::*;
use super::status_transport::*;
use super::{status_intelligence_ext::*, status_intelligence_ext2::*};
use std::path::Path;
fn try_status_phase87(
sd: &Path,
machine: Option<&str>,
json: bool,
machine_resource_drift_age: bool,
fleet_resource_drift_age: bool,
machine_resource_recovery_rate: bool,
) -> Option<Result<(), String>> {
if machine_resource_drift_age {
return Some(cmd_status_machine_resource_drift_age(sd, machine, json));
}
if fleet_resource_drift_age {
return Some(cmd_status_fleet_resource_drift_age(sd, machine, json));
}
if machine_resource_recovery_rate {
return Some(cmd_status_machine_resource_recovery_rate(sd, machine, json));
}
None
}
fn try_status_phase88(
sd: &Path,
machine: Option<&str>,
json: bool,
machine_resource_drift_velocity: bool,
fleet_resource_recovery_rate: bool,
machine_resource_convergence_efficiency: bool,
) -> Option<Result<(), String>> {
if machine_resource_drift_velocity {
return Some(cmd_status_machine_resource_drift_velocity(
sd, machine, json,
));
}
if fleet_resource_recovery_rate {
return Some(cmd_status_fleet_resource_recovery_rate(sd, machine, json));
}
if machine_resource_convergence_efficiency {
return Some(cmd_status_machine_resource_convergence_efficiency(
sd, machine, json,
));
}
None
}
fn try_status_phase89(
sd: &Path,
machine: Option<&str>,
json: bool,
machine_resource_apply_frequency: bool,
fleet_resource_health_score: bool,
machine_resource_staleness_index: bool,
) -> Option<Result<(), String>> {
if machine_resource_apply_frequency {
return Some(cmd_status_machine_resource_apply_frequency(
sd, machine, json,
));
}
if fleet_resource_health_score {
return Some(cmd_status_fleet_resource_health_score(sd, machine, json));
}
if machine_resource_staleness_index {
return Some(cmd_status_machine_resource_staleness_index(
sd, machine, json,
));
}
None
}
fn try_status_phase90(
sd: &Path,
machine: Option<&str>,
json: bool,
machine_resource_drift_recurrence: bool,
fleet_resource_drift_heatmap: bool,
machine_resource_convergence_trend_p90: bool,
) -> Option<Result<(), String>> {
if machine_resource_drift_recurrence {
return Some(cmd_status_machine_resource_drift_recurrence(
sd, machine, json,
));
}
if fleet_resource_drift_heatmap {
return Some(cmd_status_fleet_resource_drift_heatmap(sd, machine, json));
}
if machine_resource_convergence_trend_p90 {
return Some(cmd_status_machine_resource_convergence_trend_p90(
sd, machine, json,
));
}
None
}
fn try_status_phase91(
sd: &Path,
machine: Option<&str>,
json: bool,
machine_resource_drift_age_hours: bool,
fleet_resource_convergence_percentile: bool,
machine_resource_error_rate: bool,
) -> Option<Result<(), String>> {
if machine_resource_drift_age_hours {
return Some(cmd_status_machine_resource_drift_age_hours(
sd, machine, json,
));
}
if fleet_resource_convergence_percentile {
return Some(cmd_status_fleet_resource_convergence_percentile(
sd, machine, json,
));
}
if machine_resource_error_rate {
return Some(cmd_status_machine_resource_error_rate(sd, machine, json));
}
None
}
fn try_status_phase92(
sd: &Path,
machine: Option<&str>,
json: bool,
machine_resource_convergence_gap: bool,
fleet_resource_error_distribution: bool,
machine_resource_convergence_stability: bool,
) -> Option<Result<(), String>> {
if machine_resource_convergence_gap {
return Some(cmd_status_machine_resource_convergence_gap(
sd, machine, json,
));
}
if fleet_resource_error_distribution {
return Some(cmd_status_fleet_resource_error_distribution(
sd, machine, json,
));
}
if machine_resource_convergence_stability {
return Some(cmd_status_machine_resource_convergence_stability(
sd, machine, json,
));
}
None
}
#[allow(clippy::too_many_arguments)]
pub(super) fn try_status_phases_94_96(
sd: &Path,
machine: Option<&str>,
json: bool,
a1: bool,
a2: bool,
b1: bool,
b2: bool,
b3: bool,
c1: bool,
c2: bool,
c3: bool,
) -> Option<Result<(), String>> {
if a1 {
return Some(cmd_status_machine_resource_apply_latency_p95(
sd, machine, json,
));
}
if a2 {
return Some(cmd_status_fleet_resource_security_posture_score(
sd, machine, json,
));
}
if b1 {
return Some(cmd_status_fleet_apply_success_rate_trend(sd, machine, json));
}
if b2 {
return Some(cmd_status_machine_resource_drift_flapping(
sd, machine, json,
));
}
if b3 {
return Some(cmd_status_fleet_resource_type_drift_heatmap(
sd, machine, json,
));
}
if c1 {
return Some(cmd_status_machine_ssh_connection_health(sd, machine, json));
}
if c2 {
return Some(cmd_status_lock_file_staleness_report(sd, machine, json));
}
if c3 {
return Some(cmd_status_fleet_transport_method_summary(sd, machine, json));
}
None
}
#[allow(clippy::too_many_arguments)]
pub(super) fn try_status_phases_97_99(
sd: &Path,
machine: Option<&str>,
json: bool,
d1: bool,
d2: bool,
d3: bool,
e1: bool,
e2: bool,
e3: bool,
f1: bool,
f2: bool,
f3: bool,
) -> Option<Result<(), String>> {
if d1 {
return Some(cmd_status_fleet_state_churn_analysis(sd, machine, json));
}
if d2 {
return Some(cmd_status_config_maturity_score(sd, machine, json));
}
if d3 {
return Some(cmd_status_fleet_capacity_utilization(sd, machine, json));
}
if e1 {
return Some(cmd_status_fleet_drift_velocity_trend(sd, machine, json));
}
if e2 {
return Some(cmd_status_machine_convergence_window(sd, machine, json));
}
if e3 {
return Some(cmd_status_fleet_resource_age_histogram(sd, machine, json));
}
if f1 {
return Some(cmd_status_fleet_security_posture_summary(sd, machine, json));
}
if f2 {
return Some(cmd_status_machine_resource_freshness_index(
sd, machine, json,
));
}
if f3 {
return Some(cmd_status_fleet_resource_type_coverage(sd, machine, json));
}
None
}
#[allow(clippy::too_many_arguments)]
pub(super) fn try_status_phases_100_103(
sd: &Path,
machine: Option<&str>,
json: bool,
fleet_apply_cadence: bool,
machine_resource_error_classification: bool,
fleet_resource_convergence_summary: bool,
fleet_resource_staleness_report: bool,
machine_resource_type_distribution: bool,
fleet_machine_health_score: bool,
fleet_resource_dependency_lag_report: bool,
machine_resource_convergence_rate_trend: bool,
fleet_resource_apply_lag: bool,
fleet_resource_error_rate_trend: bool,
machine_resource_drift_recovery_time: bool,
fleet_resource_config_complexity_score: bool,
) -> Option<Result<(), String>> {
if fleet_apply_cadence {
return Some(cmd_status_fleet_apply_cadence(sd, machine, json));
}
if machine_resource_error_classification {
return Some(cmd_status_machine_resource_error_classification(
sd, machine, json,
));
}
if fleet_resource_convergence_summary {
return Some(cmd_status_fleet_resource_convergence_summary(
sd, machine, json,
));
}
if fleet_resource_staleness_report {
return Some(cmd_status_fleet_resource_staleness_report(
sd, machine, json,
));
}
if machine_resource_type_distribution {
return Some(cmd_status_machine_resource_type_distribution(
sd, machine, json,
));
}
if fleet_machine_health_score {
return Some(cmd_status_fleet_machine_health_score(sd, machine, json));
}
if fleet_resource_dependency_lag_report {
return Some(cmd_status_fleet_resource_dependency_lag_report(
sd, machine, json,
));
}
if machine_resource_convergence_rate_trend {
return Some(cmd_status_machine_resource_convergence_rate_trend(
sd, machine, json,
));
}
if fleet_resource_apply_lag {
return Some(cmd_status_fleet_resource_apply_lag(sd, machine, json));
}
if fleet_resource_error_rate_trend {
return Some(cmd_status_fleet_resource_error_rate_trend(
sd, machine, json,
));
}
if machine_resource_drift_recovery_time {
return Some(cmd_status_machine_resource_drift_recovery_time(
sd, machine, json,
));
}
if fleet_resource_config_complexity_score {
return Some(cmd_status_fleet_resource_config_complexity_score(
sd, machine, json,
));
}
None
}
#[allow(clippy::too_many_arguments)]
pub(super) fn try_status_phases_104_107(
sd: &Path,
machine: Option<&str>,
json: bool,
g1: bool,
g2: bool,
g3: bool,
h1: bool,
h2: bool,
h3: bool,
i1: bool,
i2: bool,
i3: bool,
j1: bool,
j2: bool,
j3: bool,
) -> Option<Result<(), String>> {
if g1 {
return Some(cmd_status_fleet_resource_maturity_index(sd, machine, json));
}
if g2 {
return Some(cmd_status_machine_resource_convergence_stability_index(
sd, machine, json,
));
}
if g3 {
return Some(cmd_status_fleet_resource_drift_pattern_analysis(
sd, machine, json,
));
}
if h1 {
return Some(cmd_status_fleet_resource_apply_success_trend(
sd, machine, json,
));
}
if h2 {
return Some(cmd_status_machine_resource_drift_age_distribution(
sd, machine, json,
));
}
if h3 {
return Some(cmd_status_fleet_resource_convergence_gap_analysis(
sd, machine, json,
));
}
if i1 {
return Some(cmd_status_fleet_resource_type_drift_correlation(
sd, machine, json,
));
}
if i2 {
return Some(cmd_status_machine_resource_apply_cadence_report(
sd, machine, json,
));
}
if i3 {
return Some(cmd_status_fleet_resource_drift_recovery_trend(
sd, machine, json,
));
}
if j1 {
return Some(cmd_status_fleet_resource_quality_score(sd, machine, json));
}
if j2 {
return Some(cmd_status_machine_resource_drift_pattern_classification(
sd, machine, json,
));
}
if j3 {
return Some(cmd_status_fleet_resource_convergence_window_analysis(
sd, machine, json,
));
}
None
}
#[allow(clippy::too_many_arguments)]
pub(super) fn try_status_phases_87_92(
sd: &Path,
machine: Option<&str>,
json: bool,
a1: bool,
a2: bool,
a3: bool,
b1: bool,
b2: bool,
b3: bool,
c1: bool,
c2: bool,
c3: bool,
d1: bool,
d2: bool,
d3: bool,
e1: bool,
e2: bool,
e3: bool,
f1: bool,
f2: bool,
f3: bool,
) -> Option<Result<(), String>> {
if let Some(r) = try_status_phase87(sd, machine, json, a1, a2, a3) {
return Some(r);
}
if let Some(r) = try_status_phase88(sd, machine, json, b1, b2, b3) {
return Some(r);
}
if let Some(r) = try_status_phase89(sd, machine, json, c1, c2, c3) {
return Some(r);
}
if let Some(r) = try_status_phase90(sd, machine, json, d1, d2, d3) {
return Some(r);
}
if let Some(r) = try_status_phase91(sd, machine, json, e1, e2, e3) {
return Some(r);
}
if let Some(r) = try_status_phase92(sd, machine, json, f1, f2, f3) {
return Some(r);
}
None
}