Přeskočit na obsah

Tato stránka byla automaticky přeložena z angličtiny, jediného jazyka, ve kterém se tento web píše. Číst originál.

server.status

Kde stojí server tohoto checkoutu — absent, starting, ready, outdated nebo stale — měřeno proti tomu, co by poskytoval tento spustitelný soubor; jak daleko je strom, který poskytuje, od vzdáleného trunku (`trunk`: current, lagging, stale, unjudged nebo unmeasured proti `checkout.trunk_distance` politiky, k poslednímu fetchi); lease, který tento proces drží, když je serverem; a, pokud `checkouts` nezúží výběr jen na tento, každý checkout, který git pro repozitář eviduje, primární první, každý se svým lease, postavením a důvodem a s peery, které hlásí jeho server. `checkouts: this` přečte jeden lease, otestuje jeden server a nevyjmenuje žádný jiný checkout, což je cena, kterou má platit volající, který se ptá jen na checkout, ve kterém je. Čte se z lease souborů a ze serverů při každém volání; nic se necachuje, protože lease zapisují jiné procesy.

Kde stojí server tohoto checkoutu — absent, starting, ready, outdated nebo stale — měřeno proti tomu, co by poskytoval tento spustitelný soubor; jak daleko je strom, který poskytuje, od vzdáleného trunku (`trunk`: current, lagging, stale, unjudged nebo unmeasured proti `checkout.trunk_distance` politiky, k poslednímu fetchi); lease, který tento proces drží, když je serverem; a, pokud `checkouts` nezúží výběr jen na tento, každý checkout, který git pro repozitář eviduje, primární první, každý se svým lease, postavením a důvodem a s peery, které hlásí jeho server. `checkouts: this` přečte jeden lease, otestuje jeden server a nevyjmenuje žádný jiný checkout, což je cena, kterou má platit volající, který se ptá jen na checkout, ve kterém je. Čte se z lease souborů a ze serverů při každém volání; nic se necachuje, protože lease zapisují jiné procesy.

  • query
  • behaviorally_verified
  • modul server
  • #server
  • #lease
  • #coordination
  • #introspection

Zpřístupnění

Kde je tato jedna definice dosažitelná. Absence je explicitní: povrch, který není uveden, ji nenese.

povrchjako
MCPnástroj majordomus_server
zdroj majordomus://server
HTTPGET /api/v1/server operationId server.status
příkazová řádkamajordomus serve status

Schémata

Kanonický vstup a výstup z typů Rustu; schéma nástroje MCP a parametry a odpovědi OpenAPI se odvozují z nich.

input · ServerStatusInput

Co žádat od server.status: jak široká je odpověď.

Jedno pole, protože stav serveru není něco, podle čeho volající filtruje — je to něco, co volající chce pro jeden checkout nebo pro všechny, a rozdíl je čtyřicet round tripů na stroji se čtyřiceti worktree.

use majordomus_cli::capability::builtin::server::{Checkouts, ServerStatusInput};
// the field is optional on every surface, and its absence is the wide answer
let asked_nothing: ServerStatusInput = serde_json::from_str("{}").unwrap();
assert_eq!(asked_nothing.checkouts, Checkouts::Repository);
let narrow: ServerStatusInput = serde_json::from_str(r#"{"checkouts":"this"}"#).unwrap();
assert_eq!(narrow.checkouts, Checkouts::This);
vlastnosttyppovinnépopis
checkouty reference ne Které checkouty odpověď pokrývá. Chybějící znamená repository. výchozí "repository"
JSON Schema 
{
  "$defs": {
    "Checkouts": {
      "description": "Which checkouts a reading of the server status covers.\n\nThe two answers cost differently and that is the whole reason the choice exists: the\nrepository's checkouts are read from git's registry of them and each one costs a lease\nread and a probe, while this checkout alone costs one of each and enumerates nothing.\nThe word each variant serialises to is the word the query parameter, the tool input and\nthe command-line flag all take.\n\n```\nuse majordomus_cli::capability::builtin::server::Checkouts;\nassert_eq!(serde_json::to_value(Checkouts::This).unwrap(), \"this\");\nassert_eq!(serde_json::to_value(Checkouts::Repository).unwrap(), \"repository\");\nassert_eq!(Checkouts::default(), Checkouts::Repository, \"the wide answer is what a caller who says nothing has always got\");\n```",
      "oneOf": [
        {
          "const": "repository",
          "description": "Every checkout git registers for the repository, the primary first — a lease read\nand a probe each. The default, because it is the answer this capability gave before\nthere was anything to ask.",
          "type": "string"
        },
        {
          "const": "this",
          "description": "This checkout alone. No other checkout is enumerated, no other lease is read and no\nother server is probed; `servers` holds the one entry, and it is this one.",
          "type": "string"
        }
      ]
    }
  },
  "additionalProperties": false,
  "description": "What to ask of `server.status`: how wide the answer is.\n\nOne field, because the standing of a server is not something a caller filters — it is\nsomething a caller wants for one checkout or for all of them, and the difference is\nforty round trips on a machine with forty worktrees.\n\n```\nuse majordomus_cli::capability::builtin::server::{Checkouts, ServerStatusInput};\n// the field is optional on every surface, and its absence is the wide answer\nlet asked_nothing: ServerStatusInput = serde_json::from_str(\"{}\").unwrap();\nassert_eq!(asked_nothing.checkouts, Checkouts::Repository);\nlet narrow: ServerStatusInput = serde_json::from_str(r#\"{\"checkouts\":\"this\"}\"#).unwrap();\nassert_eq!(narrow.checkouts, Checkouts::This);\n```",
  "properties": {
    "checkouts": {
      "$ref": "#/$defs/Checkouts",
      "default": "repository",
      "description": "Which checkouts the answer covers. Absent means `repository`."
    }
  },
  "title": "ServerStatusInput",
  "type": "object"
}

výstup · ServerStatus

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);
vlastnosttyppovinnépopis
checkout_id string ano Identita tohoto checkoutu: čím odpovídá tento proces jako repository_id.
spojení jedno ze 2 ne Co HTTP server tohoto procesu udělal s připojeními, která ho držela bez požadavku: uplatněný limit čtení, připojení, která tento limit zavřel, a požadavky odmítnuté, protože všechny obslužné rutiny byly zaneprázdněny. Chybí, pokud tento proces neobsluhuje HTTP.
požadováno reference ano Co by tento spustitelný soubor poskytoval a vůči čemu se měří standing.
git jedno ze 2 ne Repozitář git, do něhož tento checkout patří; chybí tam, kde se git nedá zeptat.
servery array ano Každý checkout repozitáře, primární první, každý se svým serverem. Jeden záznam — tento checkout — tam, kde se git nedá zeptat.
postavení reference ano Kde stojí server tohoto checkoutu.
this_process jedno ze 2 ne Pronájem, který tento proces drží, pokud je serverem; chybí, pokud odpověděl proces, který nic neobsluhuje.
trunk jedno ze 2 ne Jak daleko je strom, který tento checkout obsluhuje, od vzdáleného trunku, posuzováno podle checkout.trunk_distance politiky: server checkoutu o 779 commitů pozadu odpovídá každé relaci ze stromu, který už neexistuje, a tady se to říká. Chybí jen v odpovědi, která předchází tomuto poli.
JSON Schema 
{
  "$defs": {
    "ConnectionCounts": {
      "description": "What this process's HTTP server has done to clients that held a connection without using\nit: the deadline it applies and what that deadline cost, since the process started.\nAbsent while this process serves no HTTP.\n\n```\nuse majordomus_cli::http::deadline::{counts, ConnectionCounts};\n// a process that has started no server reports nothing, rather than zeroes that would\n// read as \"no slow client was seen\"\nassert_eq!(counts(), None);\nlet c = ConnectionCounts { read_deadline_seconds: 30, closed_by_deadline: 4, refused_busy: 0 };\nlet text = serde_json::to_string(&c).unwrap();\nassert_eq!(serde_json::from_str::<ConnectionCounts>(&text).unwrap(), c);\n```",
      "properties": {
        "closed_by_deadline": {
          "description": "Connections closed because no request was read in full on them within the deadline.",
          "format": "uint64",
          "minimum": 0,
          "type": "integer"
        },
        "read_deadline_seconds": {
          "description": "`server.read_deadline_seconds:` as this process applies it.",
          "format": "uint64",
          "minimum": 0,
          "type": "integer"
        },
        "refused_busy": {
          "description": "Requests answered 503 because every request handler was busy.",
          "format": "uint64",
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "read_deadline_seconds",
        "closed_by_deadline",
        "refused_busy"
      ],
      "type": "object"
    },
    "Desired": {
      "description": "What this executable would want a server of this checkout to be: the address it would\nbind, the version and the executable it would serve from. What `standing` is measured\nagainst.\n\n```\nuse majordomus_cli::capability::builtin::server::Desired;\nlet d = Desired { host: \"127.0.0.1\".into(), port: 8741, version: \"1.0.0\".into(), executable: None };\nlet v = serde_json::to_value(&d).unwrap();\nassert_eq!(v[\"port\"], 8741);\nassert!(v.get(\"executable\").is_none(), \"an executable that cannot be located is not written as null\");\n```",
      "properties": {
        "executable": {
          "anyOf": [
            {
              "$ref": "#/$defs/ExecutableIdentity"
            },
            {
              "type": "null"
            }
          ],
          "description": "This executable, when it can be located."
        },
        "host": {
          "description": "The interface a server started here would bind: what `MAJORDOMUS_HTTP_HOST` names\nin this process's environment, and loopback when it names nothing.",
          "type": "string"
        },
        "port": {
          "description": "The port it asks for first.",
          "format": "uint16",
          "maximum": 65535,
          "minimum": 0,
          "type": "integer"
        },
        "version": {
          "description": "This executable's version.",
          "type": "string"
        }
      },
      "required": [
        "host",
        "port",
        "version"
      ],
      "type": "object"
    },
    "Distance": {
      "description": "How many commits two refs have that the other lacks.\n\n```\nuse majordomus_cli::worktree::trunk::Distance;\nlet d = Distance { behind: 779, ahead: 0 };\nassert_eq!(serde_json::to_value(d).unwrap(), serde_json::json!({\"behind\": 779, \"ahead\": 0}));\n```",
      "properties": {
        "ahead": {
          "description": "Commits of this ref the remote trunk lacks.",
          "format": "uint64",
          "minimum": 0,
          "type": "integer"
        },
        "behind": {
          "description": "Commits of the remote trunk this ref lacks.",
          "format": "uint64",
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "behind",
        "ahead"
      ],
      "type": "object"
    },
    "ExecutableIdentity": {
      "description": "The identity of the file an executable was started from: where it is, and the mtime\nand size of the file at that path. A server outlives its own binary — a rebuild replaces\nthe file under a process that keeps serving the code it loaded hours ago — and nothing\nabout the process itself says so. This is what makes that visible.\n\n```\nuse majordomus_cli::lease::ExecutableIdentity;\nlet recorded = ExecutableIdentity { path: \"/opt/majordomus\".into(), mtime: 1_700_000_000, size: 42 };\nlet text = serde_json::to_string(&recorded).unwrap();\nassert_eq!(serde_json::from_str::<ExecutableIdentity>(&text).unwrap(), recorded);\n```",
      "properties": {
        "mtime": {
          "description": "The file's modification time, seconds since the epoch.",
          "format": "uint64",
          "minimum": 0,
          "type": "integer"
        },
        "path": {
          "description": "The path the process was started from.",
          "type": "string"
        },
        "size": {
          "description": "The file's size in bytes.",
          "format": "uint64",
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "path",
        "mtime",
        "size"
      ],
      "type": "object"
    },
    "GitIdentity": {
      "description": "The git repository a checkout belongs to, as distinct from the checkout itself.\n\n`identity` names a checkout: one server, one lease, one index per checkout root. Every\nlinked worktree of one git repository is a checkout of its own by that measure, and\nnothing in it said that they belong together. This does: the git directory every work\ntree shares (`git rev-parse --git-common-dir`) is the repository's identity, its digest\nis one value for every checkout of that repository, and `linked` says whether this\ncheckout is the primary one or a work tree hanging off it. `None` where git cannot be\nasked: a repository of the layer does not have to be version controlled.\n\n```\nuse majordomus_cli::repository::{git_identity, identity, GitIdentity};\nuse std::process::Command;\nlet dir = tempfile::tempdir().unwrap();\nlet root = dir.path().join(\"repo\");\nstd::fs::create_dir_all(&root).unwrap();\nlet git = |args: &[&str]| assert!(Command::new(\"git\").arg(\"-C\").arg(&root).args(args).status().unwrap().success());\ngit(&[\"init\", \"-q\", \".\"]);\ngit(&[\"-c\", \"user.email=t@example.com\", \"-c\", \"user.name=t\", \"commit\", \"-q\", \"--allow-empty\", \"-m\", \"init\"]);\nlet wt = dir.path().join(\"repo-wt\");\ngit(&[\"worktree\", \"add\", \"-q\", \"-b\", \"feature/x\", wt.to_str().unwrap()]);\n\nlet primary: GitIdentity = git_identity(&root).expect(\"a work tree\");\nlet linked: GitIdentity = git_identity(&wt).expect(\"a linked work tree\");\nassert_eq!(primary.id, linked.id, \"one repository\");\nassert_ne!(identity(&root), identity(&wt), \"two checkouts\");\nassert!(!primary.linked && linked.linked);\nassert!(!primary.id.contains('/'), \"a digest, never a path\");\n```",
      "properties": {
        "common_dir": {
          "description": "The git directory every work tree of the repository shares, canonical.",
          "type": "string"
        },
        "id": {
          "description": "Its digest: the same for every checkout of one repository, different across\nrepositories, and never a path.",
          "type": "string"
        },
        "linked": {
          "description": "Whether this checkout is a linked work tree rather than the primary one.",
          "type": "boolean"
        }
      },
      "required": [
        "common_dir",
        "id",
        "linked"
      ],
      "type": "object"
    },
    "LeaseView": {
      "description": "A lease as a reader sees it: what the server wrote about itself, without the token that\nmakes the file the server's own.\n\n```\nuse majordomus_cli::capability::builtin::server::LeaseView;\nlet view = LeaseView { pid: 7, url: Some(\"http://127.0.0.1:8741\".into()),\n    started_at: \"2026-09-10T00:00:00Z\".into(), executable: None, version: Some(\"1.0.0\".into()) };\nlet v = serde_json::to_value(&view).unwrap();\nassert_eq!(v[\"pid\"], 7);\nassert!(v.get(\"token\").is_none() && v.get(\"root\").is_none());\n```",
      "properties": {
        "executable": {
          "anyOf": [
            {
              "$ref": "#/$defs/ExecutableIdentity"
            },
            {
              "type": "null"
            }
          ],
          "description": "The executable the server was started from, when it could be located."
        },
        "pid": {
          "description": "The server's process id. Not proof of a live server — only a probe that is answered\nis — but decisions are made from it: a live pid earns a server that does not answer\nthe election's busy wait before its lease is taken over, and `serve ensure`'s patience\nbefore it starts another; `serve stop` sends its `SIGTERM` to this pid.",
          "format": "uint32",
          "minimum": 0,
          "type": "integer"
        },
        "started_at": {
          "description": "When the server took the lease, RFC 3339.",
          "type": "string"
        },
        "url": {
          "description": "The address, once bound.",
          "type": [
            "string",
            "null"
          ]
        },
        "version": {
          "description": "The executable's version; absent for a server too old to have written one.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "required": [
        "pid",
        "started_at"
      ],
      "type": "object"
    },
    "ServerStanding": {
      "description": "Where a checkout's server stands, decided from its lease, whether the server the lease\nnames answers for that checkout, and whether what answers is this executable's code.\n\n```\nuse majordomus_cli::capability::builtin::server::ServerStanding;\nlet all = [ServerStanding::Absent, ServerStanding::Starting, ServerStanding::Ready,\n           ServerStanding::Outdated, ServerStanding::Stale];\nlet words: Vec<&str> = all.iter().map(|s| s.as_str()).collect();\nassert_eq!(words, [\"absent\", \"starting\", \"ready\", \"outdated\", \"stale\"]);\nassert_eq!(serde_json::from_str::<ServerStanding>(\"\\\"stale\\\"\").unwrap(), ServerStanding::Stale);\n```",
      "oneOf": [
        {
          "const": "absent",
          "description": "No lease: nothing serves this checkout.",
          "type": "string"
        },
        {
          "const": "starting",
          "description": "A lease without an address, young enough that its owner is still binding.",
          "type": "string"
        },
        {
          "const": "ready",
          "description": "The server the lease names answers for this checkout, from the code on disk, at\nthis executable's version.",
          "type": "string"
        },
        {
          "const": "outdated",
          "description": "The server answers, but from older code than this executable, or from a file that\nhas been replaced since it started: everything it says is yesterday's.",
          "type": "string"
        },
        {
          "const": "stale",
          "description": "The lease names a server that does not answer, or is not a lease at all.",
          "type": "string"
        }
      ]
    },
    "ServerView": {
      "description": "One checkout of the repository, and the server its lease names.\n\n```\nuse majordomus_cli::capability::builtin::server::{ServerStanding, ServerView};\nlet view = ServerView { worktree: \"/r\".into(), branch: Some(\"master\".into()), checkout_id: \"c\".into(),\n    primary: true, this_checkout: true, standing: ServerStanding::Absent, reason: None, lease: None, peers: None };\nlet v = serde_json::to_value(&view).unwrap();\nassert_eq!(v[\"standing\"], \"absent\");\nassert!(v.get(\"lease\").is_none() && v.get(\"peers\").is_none(), \"what there is not is not written\");\n```",
      "properties": {
        "branch": {
          "description": "The branch checked out there, when git names one.",
          "type": [
            "string",
            "null"
          ]
        },
        "checkout_id": {
          "description": "The checkout's identity: what its server answers as `repository_id`.",
          "type": "string"
        },
        "lease": {
          "anyOf": [
            {
              "$ref": "#/$defs/LeaseView"
            },
            {
              "type": "null"
            }
          ],
          "description": "The lease, when the file holds one."
        },
        "peers": {
          "description": "How many peers the server reports attached, when it answers.",
          "format": "uint",
          "minimum": 0,
          "type": [
            "integer",
            "null"
          ]
        },
        "primary": {
          "description": "Whether this is the primary checkout rather than a linked worktree.",
          "type": "boolean"
        },
        "reason": {
          "description": "Why, when the standing is not `ready`: what the lease held, or what answered.",
          "type": [
            "string",
            "null"
          ]
        },
        "standing": {
          "$ref": "#/$defs/ServerStanding",
          "description": "Where its server stands."
        },
        "this_checkout": {
          "description": "Whether this is the checkout the answering process serves.",
          "type": "boolean"
        },
        "worktree": {
          "description": "The checkout, absolute and canonical.",
          "type": "string"
        }
      },
      "required": [
        "worktree",
        "checkout_id",
        "primary",
        "this_checkout",
        "standing"
      ],
      "type": "object"
    },
    "TrunkDistance": {
      "description": "A checkout's distance from the remote trunk, judged.\n\n```\nuse majordomus_cli::worktree::trunk::{Distance, TrunkDistance, TrunkStanding};\nlet d: TrunkDistance = serde_json::from_value(serde_json::json!({\n    \"standing\": \"stale\", \"local_trunk_standing\": \"stale\",\n    \"worktree\": \"/repo\", \"on_trunk\": true,\n    \"checkout\": {\"behind\": 779, \"ahead\": 0},\n    \"thresholds\": {\"warn_behind\": 50, \"fail_behind\": 300},\n    \"message\": \"779 commits behind origin/master\",\n})).unwrap();\nassert_eq!(d.standing, TrunkStanding::Stale);\nassert_eq!(d.checkout, Some(Distance { behind: 779, ahead: 0 }));\n// what is absent stays absent in the answer\nassert!(serde_json::to_value(&d).unwrap().get(\"remedy\").is_none());\n```",
      "properties": {
        "checkout": {
          "anyOf": [
            {
              "$ref": "#/$defs/Distance"
            },
            {
              "type": "null"
            }
          ],
          "description": "The checkout's `HEAD` against the remote trunk. While a merge is in progress, the\ncommits it brings in count as present: the commit being made will hold them, so the\nmerge that brings a checkout current is never judged by the tree it is replacing."
        },
        "fetched_at": {
          "description": "When the repository last fetched (the time of `FETCH_HEAD`), RFC 3339: the moment\nthis answer is true as of. Absent when it never fetched.",
          "type": [
            "string",
            "null"
          ]
        },
        "local_trunk": {
          "anyOf": [
            {
              "$ref": "#/$defs/Distance"
            },
            {
              "type": "null"
            }
          ],
          "description": "The local trunk branch against the remote trunk: what a branch made from the local\ntrunk starts from."
        },
        "local_trunk_standing": {
          "$ref": "#/$defs/TrunkStanding",
          "description": "Where the local trunk branch stands, judged the same way: what a branch made from it\nstarts from. The same as `standing` when the checkout holds the trunk."
        },
        "message": {
          "description": "What the standing means here, in one line.",
          "type": "string"
        },
        "on_trunk": {
          "description": "The work tree holds the trunk branch itself.",
          "type": "boolean"
        },
        "remedy": {
          "description": "The commands that bring the checkout and the local trunk current, when either is\nbehind. Suggested, never run.",
          "type": [
            "string",
            "null"
          ]
        },
        "remote_head": {
          "description": "The commit the remote-tracking trunk names.",
          "type": [
            "string",
            "null"
          ]
        },
        "remote_trunk": {
          "description": "The remote-tracking trunk counted against (`origin/master`).",
          "type": [
            "string",
            "null"
          ]
        },
        "standing": {
          "$ref": "#/$defs/TrunkStanding",
          "description": "Where the checkout stands: its `HEAD` — with the commit a merge in progress brings\nin — judged against the thresholds. This is what its server serves."
        },
        "thresholds": {
          "$ref": "#/$defs/TrunkThresholds",
          "description": "The thresholds judged against, as `checkout.trunk_distance` declares them."
        },
        "trunk": {
          "description": "The trunk branch, short.",
          "type": [
            "string",
            "null"
          ]
        },
        "worktree": {
          "description": "The work tree measured.",
          "type": "string"
        }
      },
      "required": [
        "standing",
        "local_trunk_standing",
        "worktree",
        "on_trunk",
        "thresholds",
        "message"
      ],
      "type": "object"
    },
    "TrunkStanding": {
      "description": "Where a checkout stands against the remote trunk.\n\n```\nuse majordomus_cli::worktree::trunk::TrunkStanding;\nlet s: TrunkStanding = serde_json::from_str(r#\"\"lagging\"\"#).unwrap();\nassert_eq!(s, TrunkStanding::Lagging);\nassert_eq!(serde_json::to_value(TrunkStanding::Unmeasured).unwrap(), \"unmeasured\");\n```",
      "oneOf": [
        {
          "const": "current",
          "description": "Behind by less than the warn threshold, or not behind at all.",
          "type": "string"
        },
        {
          "const": "lagging",
          "description": "At or past the warn threshold: what it serves is old enough to mislead.",
          "type": "string"
        },
        {
          "const": "stale",
          "description": "At or past the fail threshold: what it serves is the wrong tree.",
          "type": "string"
        },
        {
          "const": "unjudged",
          "description": "Behind, and the policy declares no threshold to judge the distance by.",
          "type": "string"
        },
        {
          "const": "unmeasured",
          "description": "The distance could not be measured: no trunk, no remote-tracking trunk, no `HEAD`.",
          "type": "string"
        }
      ]
    },
    "TrunkThresholds": {
      "description": "The thresholds `checkout.trunk_distance` declares, in commits behind the remote trunk.\nAbsent is absent: the reader supplies no default, and a distance with nothing to judge\nit against is reported as `unjudged`.\n\n```\nuse majordomus_cli::worktree::trunk::TrunkThresholds;\nlet t: TrunkThresholds = serde_json::from_str(r#\"{\"warn_behind\": 50, \"fail_behind\": 300}\"#).unwrap();\nassert_eq!((t.warn_behind, t.fail_behind), (Some(50), Some(300)));\nassert_eq!(TrunkThresholds::default().warn_behind, None, \"absent is not a default\");\n```",
      "properties": {
        "fail_behind": {
          "description": "At or past this many commits behind, the checkout is `stale`: a failure.",
          "format": "uint64",
          "minimum": 0,
          "type": [
            "integer",
            "null"
          ]
        },
        "warn_behind": {
          "description": "At or past this many commits behind, the checkout is `lagging`: a warning.",
          "format": "uint64",
          "minimum": 0,
          "type": [
            "integer",
            "null"
          ]
        }
      },
      "type": "object"
    }
  },
  "description": "The shared server of this checkout and of every other checkout of the repository.\n\n```\nuse majordomus_cli::capability::builtin::server::{Desired, ServerStanding, ServerStatus};\nlet status = ServerStatus { checkout_id: \"c\".into(), git: None,\n    desired: Desired { host: \"127.0.0.1\".into(), port: 8741, version: \"1.0.0\".into(), executable: None },\n    this_process: None, standing: ServerStanding::Absent, servers: Vec::new(),\n    connections: None, trunk: None };\nlet text = serde_json::to_string(&status).unwrap();\nassert_eq!(serde_json::from_str::<ServerStatus>(&text).unwrap(), status);\n```",
  "properties": {
    "checkout_id": {
      "description": "This checkout's identity: what this process answers as `repository_id`.",
      "type": "string"
    },
    "connections": {
      "anyOf": [
        {
          "$ref": "#/$defs/ConnectionCounts"
        },
        {
          "type": "null"
        }
      ],
      "description": "What this process's HTTP server did to connections that held it without a request:\nthe read deadline it applies, the connections that deadline closed, and the requests\nrefused because every handler was busy. Absent when this process serves no HTTP."
    },
    "desired": {
      "$ref": "#/$defs/Desired",
      "description": "What this executable would serve, and what `standing` is measured against."
    },
    "git": {
      "anyOf": [
        {
          "$ref": "#/$defs/GitIdentity"
        },
        {
          "type": "null"
        }
      ],
      "description": "The git repository this checkout belongs to; absent where git cannot be asked."
    },
    "servers": {
      "description": "Every checkout of the repository, the primary first, each with its server. One entry\n— this checkout — where git cannot be asked.",
      "items": {
        "$ref": "#/$defs/ServerView"
      },
      "type": "array"
    },
    "standing": {
      "$ref": "#/$defs/ServerStanding",
      "description": "Where this checkout's server stands."
    },
    "this_process": {
      "anyOf": [
        {
          "$ref": "#/$defs/LeaseView"
        },
        {
          "type": "null"
        }
      ],
      "description": "The lease this process holds, when it is the server; absent when the question was\nanswered by a process that serves nothing."
    },
    "trunk": {
      "anyOf": [
        {
          "$ref": "#/$defs/TrunkDistance"
        },
        {
          "type": "null"
        }
      ],
      "description": "How far the tree this checkout serves is from the remote trunk, judged against the\npolicy's `checkout.trunk_distance`: a server of a checkout 779 commits behind answers\nevery session from a tree that no longer exists, and this is where that is said.\nAbsent only from an answer that predates the field."
    }
  },
  "required": [
    "checkout_id",
    "desired",
    "standing",
    "servers"
  ],
  "title": "ServerStatus",
  "type": "object"
}

Politiky

benchmark
povinné — cíl na každém transportu, který expozice deklaruje; případy jsou ty ze vstupního typu
cache
vypnuto — každé volání spustí handler

Cíle benchmarku

Odvozeno z registru pro tento repozitář: jeden požadavek na transport a případy, které poskytuje typ vstupu. Celá matice je na stránce měření výkonu.

transportstatepřípadytargets
directpokryto2repozitář
this-checkout
mcppokryto2repozitář
this-checkout
httppokryto2repozitář
this-checkout

Prohledává názvy a popisy všech stránek, které tento web publikuje.