Enum EventBody 

pub enum EventBody {
    SessionOpened {
        info: SessionInfo,
    },
    SessionClosed {
        session: String,
    },
    ClaimAcquired {
        claim: String,
        session: String,
        scope: Vec<String>,
        intent: Option<String>,
        mode: ClaimMode,
        issue: Option<String>,
    },
    ClaimReleased {
        claim: String,
    },
    HandoverPublished {
        handover: HandoverBody,
    },
    HandoverConsumed {
        handover: String,
        session: String,
    },
    ReviewRequested {
        review: String,
        session: String,
        subject: String,
        scope: Vec<String>,
        issue: Option<String>,
        reviewer: Option<String>,
        body: Option<String>,
    },
    ReviewAnswered {
        request: String,
        session: String,
        verdict: String,
        note: Option<String>,
    },
    ReviewWithdrawn {
        request: String,
        session: String,
        note: Option<String>,
    },
}

What an event says. One vocabulary for every runtime; an event of a kind this executable does not know is stored and relayed but not interpreted, so a newer peer never breaks an older one’s replication.

The vocabulary is small on purpose: everything the mesh coordinates is a session, a claim, a handover or a review, and an event that would need a ninth kind is a feature that has not been agreed. The kind tag is what goes on the wire, so it is protocol — two executables of different ages read the same word for the same event.

use majordomus_cli::mesh::journal::{EventBody, SessionInfo, KNOWN_KINDS};

let opened = EventBody::SessionOpened { info: SessionInfo::named("s1", "cli") };
assert_eq!(opened.kind(), "session_opened");
assert!(KNOWN_KINDS.contains(&opened.kind()));
assert_eq!(serde_json::to_value(&opened).unwrap()["kind"], "session_opened");

Variants

SessionOpened

A session began, or said something new about itself (the latest wins).

Fields

info: SessionInfo

The session.

SessionClosed

A session ended. Its claims end with it.

Fields

session: String

The session id within the stream.

ClaimAcquired

A session claimed a scope.

Fields

claim: String

The claim id within the stream.

session: String

The holding session within the stream.

scope: Vec<String>

Repository-relative paths.

intent: Option<String>

What the claim is for.

mode: ClaimMode

Exclusive or advisory.

issue: Option<String>

The issue the claim is for.

ClaimReleased

A claim was released by its holder.

Fields

claim: String

The claim id within the stream.

HandoverPublished

A handover was published for other runtimes to consume.

Fields

handover: HandoverBody

The handover.

HandoverConsumed

A session consumed a handover (on any runtime).

Fields

handover: String

The handover’s content digest.

session: String

The consuming session within the stream.

ReviewRequested

A session asked for a review.

Fields

review: String

The review id within the stream.

session: String

The requesting session within the stream.

subject: String

What is to be reviewed: a branch, a commit, a pull request.

scope: Vec<String>

Paths the review covers.

issue: Option<String>

The issue.

reviewer: Option<String>

The runtime asked (<node>-<runtime>), when one was.

body: Option<String>

What the reviewer needs beyond the subject line: the evidence, the commands, the question. Up to REVIEW_BODY_MAX bytes. A runtime older than the field reads the request without it.

ReviewAnswered

A session answered a review request (on any runtime).

Fields

request: String

The request: <stream>/<review>.

session: String

The answering session within the stream.

verdict: String

approved, changes_requested, commented.

note: Option<String>

The answer’s note.

ReviewWithdrawn

The runtime that asked for a review ended its request: done, void, or superseded. Only the asking runtime writes it — from any of its sessions — so it is never a verdict; its note is the requester’s own result, shown with the request.

Fields

request: String

The request: <stream>/<review>.

session: String

The withdrawing session within the stream.

note: Option<String>

The requester’s result or reason, up to REVIEW_BODY_MAX bytes.

Implementations

impl EventBody

pub fn kind(&self) -> &'static str

The kind’s wire word: the same snake-case spelling the serialized event carries, so a counter, a log line and a peer’s JSON all name an event the same way. It is written out rather than derived from the variant name, because the word is protocol and renaming a variant must not change what another runtime reads.

use majordomus_cli::mesh::journal::{EventBody, KNOWN_KINDS};

let released = EventBody::ClaimReleased { claim: "c1".into() };
assert_eq!(released.kind(), "claim_released");
assert_eq!(serde_json::to_value(&released).unwrap()["kind"], released.kind());
assert!(KNOWN_KINDS.contains(&released.kind()));

pub fn validate(&self) -> Result<(), String>

Check the body’s bounds: short identifiers, repository-relative scopes, a bounded handover. A body out of bounds is refused before it is signed or stored.

It runs on both sides: on the writer, so a runtime never signs something its peers will refuse, and on the reader, so nothing a peer sends is stored unchecked. The bounds are not arbitrary — a scope must be repository-relative because a claim over /etc means nothing on another machine, a handover’s id must be the digest of its body or identity would be forgeable, and the fields that become front matter where a handover is consumed must be single lines.

use majordomus_cli::mesh::journal::{EventBody, HandoverBody, SessionInfo};

assert!(EventBody::SessionOpened { info: SessionInfo::named("s1", "cli") }.validate().is_ok());

// a scope that is not repository-relative is refused
let escaping = EventBody::ClaimAcquired { claim: "c1".into(), session: "s1".into(),
    scope: vec!["../../etc".into()], intent: None, mode: Default::default(), issue: None };
assert!(escaping.validate().is_err());

// and a handover whose id is not the digest of its body is not that handover
let body = "# Objective\nship\n".to_string();
let lying = EventBody::HandoverPublished { handover: HandoverBody {
    id: HandoverBody::digest_of("something else"), task: None, issue: None,
    milestone: None, branch: None, head: None, created_at: None, name: None, body } };
assert!(lying.validate().is_err());

Trait Implementations

impl Clone for EventBody

fn clone(&self) -> EventBody

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EventBody

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EventBody

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for EventBody

impl JsonSchema for EventBody

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 EventBody

fn eq(&self, other: &EventBody) -> 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 EventBody

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 EventBody