Struct RuntimeView 

pub struct RuntimeView {
    pub root: String,
    pub served_head: String,
    pub served_branch: String,
    pub served_working_tree: String,
    pub repository_head: String,
    pub repository_branch: String,
    pub repository_working_tree: String,
    pub agree: bool,
    pub objects: usize,
    pub index_state: String,
    pub note: String,
}

The commit this process answers about, against the commit the repository is on.

Both halves are read here and neither is assumed. served is what the index this process is holding was built from; repository is what git says now, on this call. A server that follows the repository reports them equal and pays one git invocation for the proof; a server that froze its index at start-up reports them different, which is the only way a reader could ever have found that out.

agree is the field with the operational meaning, and what it says is not “the repository is fine” but “the answers you are reading are about the tree you are looking at”. When it is false every other capability this process serves is answering about a commit that is no longer checked out, and nothing else in the API would tell you.

use majordomus_cli::capability::builtin::lifecycle::RuntimeView;
use serde_json::json;

let view = |served: &str, repo: &str, agree: bool| -> RuntimeView {
    serde_json::from_value(json!({
        "root": "example/repo",
        "served_head": served, "served_branch": "master", "served_working_tree": "clean",
        "repository_head": repo, "repository_branch": "master",
        "repository_working_tree": "clean",
        "agree": agree, "objects": 1319, "index_state": "ok",
        "note": "as measured on this call",
    })).unwrap()
};

// a server following the repository: one `git` invocation buys the proof
let current = view("a1b2c3d", "a1b2c3d", true);
assert!(current.agree);
assert_eq!(current.served_head, current.repository_head);
assert_eq!(current.index_state, "ok");

// and one that froze its index at start-up: every answer it serves is about the old commit
let frozen = view("a1b2c3d", "9f8e7d6", false);
assert!(!frozen.agree);
assert_ne!(frozen.served_head, frozen.repository_head);

Fields

root: String

The repository root this process is serving.

served_head: String

The commit the served index was built at.

served_branch: String

Its branch, or DETACHED.

served_working_tree: String

Whether the working tree was clean when the index was built.

repository_head: String

The commit the repository is on, read on this call.

repository_branch: String

Its branch now.

repository_working_tree: String

The working tree now.

agree: bool

Whether the two agree on the commit and the branch.

objects: usize

How many objects the served index holds, and whether it was degraded.

index_state: String

ok or degraded.

note: String

What the comparison means, and what to do when it disagrees.

Trait Implementations

impl Clone for RuntimeView

fn clone(&self) -> RuntimeView

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RuntimeView

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RuntimeView

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for RuntimeView

impl JsonSchema for RuntimeView

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for RuntimeView

fn eq(&self, other: &RuntimeView) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for RuntimeView

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RuntimeView