Struct RunRecord 

pub struct RunRecord {

    pub schema: String,
    pub decision_id: String,
    pub plan_id: PlanId,
    pub execution: RecordedExecution,
    pub termination: Termination,
    pub core: CoreEvidence,
    pub timing: Timing,
    pub requests: Vec<RequestRecord>,
    pub cost: CostSummary,
    pub remote_evidence: Option<Vec<RemoteEvidence>>,
    pub remote_evidence_truncated: bool,
    pub acquisitions: Option<Vec<AcquisitionRecord>>,
    pub decision_cache: Option<DecisionCacheRecord>,
}

Fields

schema: String

decision_id: String

Supplied by the caller; the delivery key sinks deduplicate by.

plan_id: PlanId

execution: RecordedExecution

termination: Termination

core: CoreEvidence

timing: Timing

requests: Vec<RequestRecord>

In the order the core listed them.

cost: CostSummary

remote_evidence: Option<Vec<RemoteEvidence>>

rustev.run/2 only (spec 020, 3.2): at most one entry per remote attempt, in attempt order, at most MAX_REMOTE_EVIDENCE. Absent in every other version, so their bytes are unchanged.

remote_evidence_truncated: bool

rustev.run/2 only: remote attempts beyond the bound have no entry.

acquisitions: Option<Vec<AcquisitionRecord>>

Spec 036: omitted when the plan has no acquisition step.

decision_cache: Option<DecisionCacheRecord>

rustev.run/3 only (spec 044, 3.6.6): omitted when the plan has no decision-result cache.

Implementations

impl RunRecord

pub fn check_version_members(&self) -> Result<(), RunVersionError>

Whether the version-specific members fit the schema: the remote evidence list exactly in rustev.run/2, within its bounds.

pub fn project_v1(&self) -> Result<RunRecord, RunVersionError>

The deterministic version 1 projection of a rustev.run/2 record (spec 020, 3.2): the remote evidence removed, the schema tag changed, every other member exactly as it is, so the canonical bytes are the version 1 representation. Refused, never partial, for any other record.

Trait Implementations

impl Clone for RunRecord

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RunRecord

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RunRecord

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Document for RunRecord

const SCHEMA: &'static str = schema::RUN

The schema string this document carries (spec 002, 3.2.1).

const LIMITS: ParseLimits = RECORD_V1

The limit set its bytes are scanned against (spec 002, 3.2.5).

fn schema(&self) -> &str

The value of the document’s own schema field.

fn parse(bytes: &[u8]) -> Result<Self, DocumentError>

Scan, deserialize and check the schema string.

fn record_digest(&self) -> Result<ContentDigest, CanonicalError>

sha256(SCHEMA || 0x00 || record canonical bytes) (spec 004, 3.1.6). Equal to the identity of an identified document.

fn canonical(&self) -> Result<Vec<u8>, CanonicalError>

The canonical bytes (spec 002, 3.3.1).

fn record_canonical(&self) -> Result<Vec<u8>, CanonicalError>

where Self: PartialEq,

The record canonical bytes (spec 004, 5.6): the canonical bytes, with finite fractional numbers written in shortest round-trip form.

impl JsonSchema for RunRecord

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 RunRecord

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for RunRecord

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 RunRecord