Struct EvidenceProvenance 

pub struct EvidenceProvenance {
    pub producer: Option<EvidenceProducer>,
    pub commit: String,
    pub working_tree: TreeState,
    pub excluded: Vec<String>,
    pub measured_at: Option<String>,
    pub toolchain: Option<EvidenceToolchain>,
    pub recorder: Option<String>,
    pub report: Option<EvidenceReportArtifact>,
    pub host: Option<EvidenceHost>,
    pub run: Option<RunRef>,
}

What a run measured about its own checkout when it ended.

Only commit and working_tree are required: a producing job’s tree file ({"commit","working_tree","excluded"}) is a valid, minimal measurement. It names no report, so it is accepted only for a CI recording.

use majordomus_cli::evidence::{EvidenceProvenance, TreeState};
let head = "0123456789abcdef0123456789abcdef01234567";
let p: EvidenceProvenance = serde_json::from_value(serde_json::json!({
    "commit": head, "working_tree": "clean", "excluded": ["suite.tsv"]
})).unwrap();
assert_eq!(p.working_tree, TreeState::Clean);
assert!(p.report.is_none());

Fields

producer: Option<EvidenceProducer>

Which report this measures, when named.

commit: String

The full commit the checkout was at.

working_tree: TreeState

The tree, the evidence ledger ignored and the run’s own untracked outputs excluded.

excluded: Vec<String>

The run’s own untracked outputs that were excluded, the report among them when it is inside the checkout. The ledger is always ignored and not listed.

measured_at: Option<String>

When it was measured, RFC 3339 UTC.

toolchain: Option<EvidenceToolchain>

The producer’s toolchain.

recorder: Option<String>

The version of the executable that measured.

report: Option<EvidenceReportArtifact>

The report measured.

host: Option<EvidenceHost>

The machine.

run: Option<RunRef>

The CI run, when there was one.

Implementations

impl EvidenceProvenance

pub fn read(path: &Path) -> Result<EvidenceProvenance, String>

The measurement a file holds, or why it holds none: an unreadable file, bad JSON, an unknown field or a tree word that is not one, each naming the file.

use majordomus_cli::evidence::EvidenceProvenance;
let dir = tempfile::tempdir().unwrap();
let f = dir.path().join("p.json");
std::fs::write(&f, r#"{"commit":"c","working_tree":"clean","extra":1}"#).unwrap();
assert!(EvidenceProvenance::read(&f).unwrap_err().contains("p.json"));

pub fn resolve( values: &[String], given: &[EvidenceProducer], ) -> Result<BTreeMap<EvidenceProducer, EvidenceProvenance>, String>

The measurement of each report, from --provenance values (<file> or <producer>=<file>) and the producers whose reports were given.

A value’s producer is its key, else the file’s own, else the only report given; refused when none of those names one, when a key and the file disagree, and when a producer is given two measurements.

use majordomus_cli::evidence::{EvidenceProducer, EvidenceProvenance};
let dir = tempfile::tempdir().unwrap();
let f = dir.path().join("p.json");
std::fs::write(&f, r#"{"commit":"c","working_tree":"clean"}"#).unwrap();
let v = vec![f.display().to_string()];
let got = EvidenceProvenance::resolve(&v, &[EvidenceProducer::Suite]).unwrap();
assert_eq!(got[&EvidenceProducer::Suite].producer, Some(EvidenceProducer::Suite));
let two = [EvidenceProducer::Suite, EvidenceProducer::Crate];
assert!(EvidenceProvenance::resolve(&v, &two).unwrap_err().contains("<producer>=<file>"));

Trait Implementations

impl Clone for EvidenceProvenance

fn clone(&self) -> EvidenceProvenance

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for EvidenceProvenance

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EvidenceProvenance

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for EvidenceProvenance

impl JsonSchema for EvidenceProvenance

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for EvidenceProvenance

fn eq(&self, other: &EvidenceProvenance) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for EvidenceProvenance

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for EvidenceProvenance