Struct Withheld 

pub struct Withheld {
    pub withheld: String,
    pub bytes: usize,
    pub limit: usize,
    pub itself: String,
}

What an event carries in place of a value too large for one frame: why it was withheld, how large it is, and where the whole value is read.

The event is still the same typed event, with its sequence, so nothing about the execution’s story is lost — only the value is read elsewhere, from the snapshot.

use majordomus_cli::http::events::Withheld;
let w = Withheld {
    withheld: "too_large".into(),
    bytes: 2_000_000,
    limit: 1_048_576,
    itself: "/api/v1/executions/get?id=e1".into(),
};
let json = serde_json::to_value(&w).unwrap();
assert_eq!(json["self"], "/api/v1/executions/get?id=e1", "the reference is `self` on the wire");
assert!(json.get("itself").is_none());
assert_eq!(serde_json::from_value::<Withheld>(json).unwrap(), w);

Fields

withheld: String

Why: always too_large.

bytes: usize

The size of the value as JSON, in bytes.

limit: usize

The largest frame this server writes, ws::MAX_FRAME_BYTES.

itself: String

The snapshot that carries the whole value: GET /api/v1/executions/get?id=….

Trait Implementations

impl Clone for Withheld

fn clone(&self) -> Withheld

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Withheld

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Withheld

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Withheld

impl JsonSchema for Withheld

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 Withheld

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

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 Withheld