HTTP API: server

What this process's HTTP server has done to clients that held a connection without using it: the deadline it applies and what that deadline cost, since the process started. Absent while this process serves no 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);

What this executable would want a server of this checkout to be: the address it would bind, the version and the executable it would serve from. What standing is measured against.

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

The identity of the file an executable was started from: where it is, and the mtime and size of the file at that path. A server outlives its own binary — a rebuild replaces the file under a process that keeps serving the code it loaded hours ago — and nothing about the process itself says so. This is what makes that visible.

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

The git repository a checkout belongs to, as distinct from the checkout itself.

identity names a checkout: one server, one lease, one index per checkout root. Every linked worktree of one git repository is a checkout of its own by that measure, and nothing in it said that they belong together. This does: the git directory every work tree shares (git rev-parse --git-common-dir) is the repository's identity, its digest is one value for every checkout of that repository, and linked says whether this checkout is the primary one or a work tree hanging off it. None where git cannot be asked: a repository of the layer does not have to be version controlled.

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

A lease as a reader sees it: what the server wrote about itself, without the token that makes the file the server's own.

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

The shared server of this checkout and of every other checkout of the repository.

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 };
let text = serde_json::to_string(&status).unwrap();
assert_eq!(serde_json::from_str::<ServerStatus>(&text).unwrap(), status);

One checkout of the repository, and the server its lease names.

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