Struct HandoverBody 

pub struct HandoverBody {
    pub id: String,
    pub task: Option<String>,
    pub issue: Option<String>,
    pub milestone: Option<String>,
    pub branch: Option<String>,
    pub head: Option<String>,
    pub created_at: Option<String>,
    pub name: Option<String>,
    pub body: String,
}

A handover as the mesh carries it: the record’s facts and its body, bounded.

What travels is the writing, plus the few facts that let a receiver file it — the task, the issue, the branch, the commit. No path of the author’s disk is among them, because the checkout that reads this is somewhere else and a path from another machine is at best noise. Identity is the digest of the body, so a handover published twice by a retry or by two runtimes is one handover everywhere.

use majordomus_cli::mesh::journal::HandoverBody;

let body = "# Objective\nship the mesh\n".to_string();
let handover = HandoverBody {
    id: HandoverBody::digest_of(&body),
    task: Some("t-1".into()),
    issue: Some("#184".into()),
    milestone: None,
    branch: Some("feature/mesh-cooperation".into()),
    head: None,
    created_at: None,
    name: None,
    body,
};
assert_eq!(handover.id, HandoverBody::digest_of(&handover.body));

let wire = serde_json::to_value(&handover).unwrap();
assert!(wire.get("milestone").is_none(), "what it does not say is omitted");

Fields

id: String

The content digest (32 hex): the same handover published twice is one handover.

task: Option<String>

The task the handover closes or continues.

issue: Option<String>

The issue it belongs to.

milestone: Option<String>

The milestone it belongs to.

branch: Option<String>

The branch it was written on.

head: Option<String>

The commit it was written at.

created_at: Option<String>

When it was written, RFC 3339, as its author’s clock said.

name: Option<String>

The record’s file name at its origin, informational.

body: String

The Markdown body (# Objective, # Current State, # Next Action, …).

Implementations

impl HandoverBody

pub fn digest_of(body: &str) -> String

The content digest a handover body is identified by. Identifying a handover by what it says rather than by who published it is what makes publication idempotent across the mesh: a retry, a relay and a second publisher all produce the same id, and the fold keeps one handover with one list of consumers.

use majordomus_cli::mesh::journal::HandoverBody;

let body = "# Objective\nship\n";
assert_eq!(HandoverBody::digest_of(body).len(), 32);
assert_eq!(HandoverBody::digest_of(body), HandoverBody::digest_of(body));
assert_ne!(HandoverBody::digest_of(body), HandoverBody::digest_of("# Objective\nwait\n"));

Trait Implementations

impl Clone for HandoverBody

fn clone(&self) -> HandoverBody

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HandoverBody

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for HandoverBody

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for HandoverBody

impl JsonSchema for HandoverBody

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 HandoverBody

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

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 HandoverBody