Enum ServedVerdict 

pub enum ServedVerdict {
    Served,
    Stale,
    Unreachable,
    Malformed,
    Dirty,
    Undecided,
}

What an observation says about the expected commit. Only ServedVerdict::Served is a proof; the other five are each a different reason the question was not answered yes.

use majordomus_cli::served::ServedVerdict;
// a measured no and an unanswered question are never spelled the same
assert!(ServedVerdict::Served.passes());
assert_eq!(ServedVerdict::Stale.exit_code(), 10);
assert_eq!(ServedVerdict::Unreachable.exit_code(), 12);

Variants

Served

The served build is the expected commit or contains it. The only passing verdict.

Stale

The served build does not contain the expected commit: the deployment is behind.

Unreachable

Nothing was received. The deployment was not measured.

Malformed

Something was received and it is not a build identity.

Dirty

The served build was made from an uncommitted tree, so it proves no commit.

Undecided

The served commit is not in this clone, or git could not be asked; containment is undecided. Fetching the remote usually turns this into an answer.

Implementations

impl ServedVerdict

pub fn as_str(self) -> &'static str

The word every surface prints — the command line, the HTTP body and the MCP result all render the verdict through this one spelling.

use majordomus_cli::served::ServedVerdict;
assert_eq!(ServedVerdict::Undecided.as_str(), "undecided");
assert_eq!(ServedVerdict::Dirty.as_str(), "dirty");

pub fn passes(self) -> bool

Whether this verdict proves the expected commit is deployed.

use majordomus_cli::served::ServedVerdict;
assert!(ServedVerdict::Served.passes());
// a site nobody could reach is not a site that serves the commit
assert!(!ServedVerdict::Unreachable.passes());
assert!(!ServedVerdict::Dirty.passes());

pub fn exit_code(self) -> i32

The exit status the command line reports it with: 0 a proof, 10 a measured “no”, 12 a question that could not be answered. The same three codes scripts/pages verify uses, so a caller of either reads one convention.

use majordomus_cli::served::ServedVerdict;
assert_eq!(ServedVerdict::Served.exit_code(), 0);
assert_eq!(ServedVerdict::Dirty.exit_code(), 10);      // measured, and a no
assert_eq!(ServedVerdict::Malformed.exit_code(), 12);  // not measured at all

Trait Implementations

impl Clone for ServedVerdict

fn clone(&self) -> ServedVerdict

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ServedVerdict

impl Debug for ServedVerdict

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ServedVerdict

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ServedVerdict

impl JsonSchema for ServedVerdict

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 ServedVerdict

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

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 ServedVerdict