HTTP API: served

The build identity a deployment serves, as far as this module relies on it. Other fields of the served document are ignored rather than refused: the document is written by another program, and a field it adds is not a malformation.

use majordomus_cli::served::BuildIdentity;
let id = BuildIdentity {
    commit: "a".repeat(40),
    dirty: false,
    source_version: Some("0.7.0".into()),
    source_hash: None,
};
// what is judged is the commit and whether the tree it was built from was committed
assert_eq!(id.commit.len(), 40);
assert!(!id.dirty);

One deployment's newest record and what it proves about the commit asked. Both are carried: the recorded judgement is what was seen, now is what it still proves.

use majordomus_cli::capability::builtin::served::DeploymentStanding;
use majordomus_cli::served::ServedVerdict;
let json = r#"{"deployment":"pages","observation":{"schema":"majordomus.served-observation/v1",
  "deployment":"pages","url":"https://majordomus.dev/build.json",
  "expected":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","verdict":"served",
  "reason":"the deployment serves aaaaaaaaaaaa","at":"1970-01-01T00:00:00Z"},
  "now":{"verdict":"stale","reason":"it does not contain bbbbbbbbbbbb"}}"#;
let s: DeploymentStanding = serde_json::from_str(json).unwrap();
// seen as served, and no longer proving the commit asked about
assert_eq!(s.observation.judgement.verdict, ServedVerdict::Served);
assert_eq!(s.now.verdict, ServedVerdict::Stale);

The judgement of one served identity against one expected commit, with its reason. The reason travels with the verdict so that every surface can say why without re-deriving it.

use majordomus_cli::served::{judge, Fetched, Judgement, ServedVerdict};
let j: Judgement = judge(&Err(Fetched::Unreachable("timeout".into())), &"a".repeat(40), &fake());
assert_eq!(j.verdict, ServedVerdict::Unreachable);
assert!(j.reason.contains("timeout"));
#### use majordomus_cli::served::Ancestry;
#### struct N; impl Ancestry for N {
####     fn has(&self, _: &str) -> Option<bool> { Some(true) }
####     fn contains(&self, _: &str, _: &str) -> Option<bool> { Some(true) }
#### }
#### fn fake() -> impl Ancestry { N }

One observation of one deployment, as recorded: what was asked, what was served, what was judged and when. Everything needed to judge it again later is in the record, which is what lets Observation::rejudge answer without probing.

use majordomus_cli::served::{observe, Fetch, Fetched, GitAncestry, Observation, OBSERVATION_SCHEMA};
use std::{path::Path, time::SystemTime};
struct None_;
impl Fetch for None_ {
    fn fetch(&self, _: &str) -> Fetched { Fetched::Unreachable("no route".into()) }
}
let git = GitAncestry { root: Path::new(env!("CARGO_MANIFEST_DIR")) };
let o: Observation = observe("pages", "https://s", "build.json", &"a".repeat(40), &None_,
                              &git, SystemTime::UNIX_EPOCH);
assert_eq!(o.schema, OBSERVATION_SCHEMA);
assert_eq!(o.url, "https://s/build.json");
assert_eq!(o.at, "1970-01-01T00:00:00Z");

Every deployment's standing against one commit: the answer served.show gives on the command line, over HTTP and to an MCP client, from one derivation.

use majordomus_cli::capability::builtin::served::{standing, ServedStanding};
use majordomus_cli::served::{Ancestry, OBSERVATIONS_PATH};
#### struct A; impl Ancestry for A {
####     fn has(&self, _: &str) -> Option<bool> { Some(true) }
####     fn contains(&self, _: &str, _: &str) -> Option<bool> { Some(true) } }
let dir = tempfile::tempdir().unwrap();
let s: ServedStanding = standing(dir.path(), &"a".repeat(40), None, &A);
assert_eq!(s.observations, OBSERVATIONS_PATH);
assert!(s.deployments.is_empty(), "nothing observed yet");
assert_eq!(s.unreadable, 0);

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);