HTTP API: server

Co HTTP server tohoto procesu udělal klientům, kteří drželi spojení bez jeho použití: uplatněný deadline a co ten deadline stál od startu procesu. Chybí, dokud tento proces neservíruje HTTP.

use majordomus_cli::http::deadline::{counts, ConnectionCounts};
// a process that has started no server reports nothing, rather than zeroes that would
// read as "no slow client was seen"
assert_eq!(counts(), None);
let c = ConnectionCounts { read_deadline_seconds: 30, closed_by_deadline: 4, refused_busy: 0 };
let text = serde_json::to_string(&c).unwrap();
assert_eq!(serde_json::from_str::<ConnectionCounts>(&text).unwrap(), c);

Čím by tento spustitelný soubor chtěl, aby server tohoto checkoutu byl: adresa, na kterou by se navázal, verze a spustitelný soubor, ze kterého by servíroval. Vůči tomu se měří standing.

use majordomus_cli::capability::builtin::server::Desired;
let d = Desired { host: "127.0.0.1".into(), port: 8741, version: "1.0.0".into(), executable: None };
let v = serde_json::to_value(&d).unwrap();
assert_eq!(v["port"], 8741);
assert!(v.get("executable").is_none(), "an executable that cannot be located is not written as null");

Identita souboru, ze kterého byl spustitelný program spuštěn: kde leží a mtime a velikost souboru na dané cestě. Server přežije vlastní binárku — rebuild nahradí soubor pod procesem, který dál obsluhuje kód načtený před hodinami — a nic na procesu samotném to neříká. Právě to to zviditelňuje.

use majordomus_cli::lease::ExecutableIdentity;
let recorded = ExecutableIdentity { path: "/opt/majordomus".into(), mtime: 1_700_000_000, size: 42 };
let text = serde_json::to_string(&recorded).unwrap();
assert_eq!(serde_json::from_str::<ExecutableIdentity>(&text).unwrap(), recorded);

Repozitář gitu, k němuž checkout patří, odlišný od samotného checkoutu.

identity jmenuje checkout: jeden server, jeden lease, jeden index na kořen checkoutu. Každý propojený worktree jednoho git repozitáře je podle této míry vlastním checkoutem a nic v tom neříkalo, že patří k sobě. Tohle říká: adresář gitu, který sdílí všechny pracovní stromy (git rev-parse --git-common-dir), je identitou repozitáře, jeho digest je jedna hodnota pro každý checkout toho repozitáře a linked říká, zda je tento checkout primární, nebo pracovní strom z něj odvozený. None, kde se git nedá zeptat: repozitář vrstvy nemusí být verzován.

use majordomus_cli::repository::{git_identity, identity, GitIdentity};
use std::process::Command;
let dir = tempfile::tempdir().unwrap();
let root = dir.path().join("repo");
std::fs::create_dir_all(&root).unwrap();
let git = |args: &[&str]| assert!(Command::new("git").arg("-C").arg(&root).args(args).status().unwrap().success());
git(&["init", "-q", "."]);
git(&["-c", "user.email=t@example.com", "-c", "user.name=t", "commit", "-q", "--allow-empty", "-m", "init"]);
let wt = dir.path().join("repo-wt");
git(&["worktree", "add", "-q", "-b", "feature/x", wt.to_str().unwrap()]);

let primary: GitIdentity = git_identity(&root).expect("a work tree");
let linked: GitIdentity = git_identity(&wt).expect("a linked work tree");
assert_eq!(primary.id, linked.id, "one repository");
assert_ne!(identity(&root), identity(&wt), "two checkouts");
assert!(!primary.linked && linked.linked);
assert!(!primary.id.contains('/'), "a digest, never a path");

Lease tak, jak ho vidí čtenář: co server napsal o sobě, bez tokenu, který činí soubor vlastním souborem serveru.

use majordomus_cli::capability::builtin::server::LeaseView;
let view = LeaseView { pid: 7, url: Some("http://127.0.0.1:8741".into()),
    started_at: "2026-09-10T00:00:00Z".into(), executable: None, version: Some("1.0.0".into()) };
let v = serde_json::to_value(&view).unwrap();
assert_eq!(v["pid"], 7);
assert!(v.get("token").is_none() && v.get("root").is_none());

Sdílený server tohoto checkoutu a každého dalšího checkoutu repozitáře.

use majordomus_cli::capability::builtin::server::{Desired, ServerStanding, ServerStatus};
let status = ServerStatus { checkout_id: "c".into(), git: None,
    desired: Desired { host: "127.0.0.1".into(), port: 8741, version: "1.0.0".into(), executable: None },
    this_process: None, standing: ServerStanding::Absent, servers: Vec::new(),
    connections: None, trunk: None };
let text = serde_json::to_string(&status).unwrap();
assert_eq!(serde_json::from_str::<ServerStatus>(&text).unwrap(), status);

Jeden checkout repozitáře a server, který jmenuje jeho lease.

use majordomus_cli::capability::builtin::server::{ServerStanding, ServerView};
let view = ServerView { worktree: "/r".into(), branch: Some("master".into()), checkout_id: "c".into(),
    primary: true, this_checkout: true, standing: ServerStanding::Absent, reason: None, lease: None, peers: None };
let v = serde_json::to_value(&view).unwrap();
assert_eq!(v["standing"], "absent");
assert!(v.get("lease").is_none() && v.get("peers").is_none(), "what there is not is not written");