HTTP API: served

Identita buildu, kterou nasazení poskytuje, tak daleko, jak se na ni tento modul spoléhá. Ostatní pole poskytovaného dokumentu se ignorují, ne odmítají: dokument píše jiný program a pole, které přidá, není poškození.

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

Nejnovější záznam jednoho nasazení a co dokazuje o dotazovaném commitu. Nese se obojí: zaznamenané posouzení je to, co bylo viděno, now je to, co stále dokazuje.

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

Posouzení jedné poskytované identity proti jednomu očekávanému commitu, s důvodem. Důvod putuje s verdiktem, aby každý povrch mohl říct proč, aniž by jej odvozoval znovu.

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 }

Jedno pozorování jednoho nasazení, tak jak bylo zaznamenáno: na co se ptalo, co bylo servírováno, co bylo posouzeno a kdy. Vše potřebné k jeho opětovnému posouzení je v záznamu, což umožňuje Observation::rejudge odpovídat bez zkoumání.

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

Stav každého nasazení vůči jednomu commitu: odpověď, kterou dává served.show na příkazové řádce, přes HTTP a klientovi MCP, z jedné derivace.

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

Co pozorování říká o očekávaném commitu. Důkazem je jen ServedVerdict::Served; ostatních pět je každé jiným důvodem, proč otázka nebyla zodpovězena ano.

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