Struct Preflight 

pub struct Preflight {
    pub schema: String,
    pub generated_at: String,
    pub resolution: Resolution,
    pub repository: String,
    pub branch: Option<String>,
    pub head: Option<String>,
    pub sections: Vec<Section>,
    pub attention: Vec<String>,
}

Whether Majordomus is in force in this checkout, claim by claim, with the evidence.

use majordomus_cli::environment::preflight::{derive, Observations, Preflight};
let p = derive(&Observations::empty("demo", 0));
assert_eq!(p.schema, Preflight::schema_id());
assert_eq!(p.verdicts().len(), p.sections.iter().map(|s| s.checks.len()).sum::<usize>());

Fields

schema: String

majordomus/preflight/v1.

generated_at: String

When the observations were taken, RFC 3339 in UTC.

resolution: Resolution

How the environment behind it was resolved.

repository: String

The repository’s name.

branch: Option<String>

The branch, when git named one.

head: Option<String>

The commit HEAD names.

sections: Vec<Section>

The groups of checks.

attention: Vec<String>

The ids of every check that needs a look, most urgent first.

Implementations

impl Preflight

pub fn schema_id() -> String

The schema identity a document of this shape carries.

use majordomus_cli::environment::preflight::Preflight;
assert_eq!(Preflight::schema_id(), "majordomus/preflight/v1");

pub fn check(&self, id: &str) -> Option<&Check>

One check by its dotted id, or None for an id no section declares — which a caller must not read as a check that passed.

use majordomus_cli::environment::preflight::{derive, Observations};
let p = derive(&Observations::empty("demo", 0));
assert!(p.check("session.episode").is_some());
assert!(p.check("nothing.here").is_none());

pub fn verdicts(&self) -> BTreeMap<String, Verdict>

Every check’s verdict by id: the part two surfaces must agree on.

use majordomus_cli::environment::preflight::{derive, Observations, Verdict};
let v = derive(&Observations::empty("demo", 0)).verdicts();
assert_eq!(v["verification.coverage"], Verdict::Unavailable);

Trait Implementations

impl Clone for Preflight

fn clone(&self) -> Preflight

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Preflight

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Preflight

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Preflight

impl JsonSchema for Preflight

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 Preflight

fn eq(&self, other: &Preflight) -> 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 Preflight

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 Preflight