canic-cli 0.83.8

Operator CLI for Canic fleet setup, builds, evidence, catalog, backup, and restore workflows
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

//! Module: evidence::options
//!
//! Responsibility: parse typed `canic evidence` command options from Clap matches.
//! Does not own: command dispatch, policy evaluation, report comparison, or output rendering.
//! Boundary: typed CLI request extraction for evidence commands.

use crate::cli::clap::{parse_matches, path_option, required_path};
use std::{ffi::OsString, path::PathBuf};

use super::{
    EvidenceCommandError,
    command::{
        EVIDENCE_ENVELOPE_ARG, JSON_ARG, compare_usage, evidence_compare_command,
        evidence_gate_command, gate_usage,
    },
};

///
/// EvidenceCompareOptions
///
#[derive(Clone, Debug, Eq, PartialEq)]
pub(super) struct EvidenceCompareOptions {
    pub(super) left: PathBuf,
    pub(super) right: PathBuf,
    pub(super) format: EvidenceCompareFormat,
}

impl EvidenceCompareOptions {
    pub(super) fn parse<I>(args: I) -> Result<Self, EvidenceCommandError>
    where
        I: IntoIterator<Item = OsString>,
    {
        let matches = parse_matches(evidence_compare_command(), args)
            .map_err(|_| EvidenceCommandError::Usage(compare_usage()))?;
        Ok(Self {
            left: required_path(&matches, "left"),
            right: required_path(&matches, "right"),
            format: evidence_compare_format(matches.get_flag(JSON_ARG)),
        })
    }
}

///
/// EvidenceCompareFormat
///
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(super) enum EvidenceCompareFormat {
    Text,
    Json,
}

///
/// EvidenceGateOptions
///
#[derive(Clone, Debug, Eq, PartialEq)]
pub(super) struct EvidenceGateOptions {
    pub(super) policy: PathBuf,
    pub(super) input: EvidenceGateInput,
    pub(super) format: EvidenceGateFormat,
    pub(super) output: Option<PathBuf>,
}

///
/// EvidenceGateInput
///
#[derive(Clone, Debug, Eq, PartialEq)]
pub(super) enum EvidenceGateInput {
    Envelope(PathBuf),
    Manifest(PathBuf),
}

impl EvidenceGateOptions {
    pub(super) fn parse<I>(args: I) -> Result<Self, EvidenceCommandError>
    where
        I: IntoIterator<Item = OsString>,
    {
        let matches = parse_matches(evidence_gate_command(), args)
            .map_err(|_| EvidenceCommandError::Usage(gate_usage()))?;
        Ok(Self {
            policy: required_path(&matches, "policy"),
            input: if let Some(envelope) = path_option(&matches, "envelope") {
                EvidenceGateInput::Envelope(envelope)
            } else {
                EvidenceGateInput::Manifest(
                    path_option(&matches, "manifest").expect(
                        "clap requires one of envelope or manifest through gate-input group",
                    ),
                )
            },
            format: evidence_gate_format(
                matches.get_flag(JSON_ARG),
                matches.get_flag(EVIDENCE_ENVELOPE_ARG),
            ),
            output: path_option(&matches, "output"),
        })
    }
}

///
/// EvidenceGateFormat
///
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(super) enum EvidenceGateFormat {
    Text,
    Json,
    EnvelopeJson,
}

const fn evidence_compare_format(json: bool) -> EvidenceCompareFormat {
    if json {
        EvidenceCompareFormat::Json
    } else {
        EvidenceCompareFormat::Text
    }
}

const fn evidence_gate_format(json: bool, evidence_envelope: bool) -> EvidenceGateFormat {
    match (json, evidence_envelope) {
        (true, false) => EvidenceGateFormat::Json,
        (false, true) => EvidenceGateFormat::EnvelopeJson,
        _ => EvidenceGateFormat::Text,
    }
}