Struct StreamMark 

pub struct StreamMark {
    pub seq: u64,
    pub beat: u64,
    pub age_ms: Option<u64>,
    pub pk: Option<String>,
    pub sig: Option<String>,
}

What a runtime knows of one stream: the contiguous high-water sequence, the highest beat with its origin’s signature, and how long ago that beat was seen to rise (None when never).

A mark is both halves of replication in one value. The sequence is what a peer compares to decide what to send, which is why replication is a comparison rather than a flood. The beat is how liveness crosses machines without comparing clocks: the origin signs it, a relay forwards the signature and adds how long ago it saw the beat rise, and the reader converts that to freshness on its own monotonic clock. Because only the origin can sign its beat, a relay can carry a stream’s liveness without being able to invent it.

use std::sync::Arc;
use majordomus_cli::mesh::identity::NodeIdentity;
use majordomus_cli::mesh::journal::{EventBody, Journal, StreamMark};

let j = Journal::open(Arc::new(NodeIdentity::ephemeral().unwrap()), "0000000000000001",
    "repo".into(), None).unwrap();
j.append_own(EventBody::SessionClosed { session: "s1".into() }).unwrap();
j.beat_own();

let marks = j.marks();
let mark: &StreamMark = &marks[&j.own_stream()];
assert_eq!(mark.seq, 1, "every event up to here is held");
assert!(mark.beat > 0 && mark.sig.is_some(), "the beat is the origin's signed statement");

Fields

seq: u64

Every event up to and including this sequence is held.

beat: u64

The highest beat heard.

age_ms: Option<u64>

Milliseconds since that beat rose, on the sender’s monotonic clock. Clamped by the reader to its expiry: a relay can report a beat stale, never older than dead.

pk: Option<String>

The origin’s public key, hex: the beat is its statement.

sig: Option<String>

The origin’s signature over the stream and the beat, hex. A relay forwards it verbatim; only the origin can raise its own beat.

Trait Implementations

impl Clone for StreamMark

fn clone(&self) -> StreamMark

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StreamMark

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

Formats the value using the given formatter.

impl Default for StreamMark

fn default() -> StreamMark

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for StreamMark

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for StreamMark

impl JsonSchema for StreamMark

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 StreamMark

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

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 StreamMark