Struct Contract 

pub struct Contract {

    pub name: String,
    pub profile: Profile,
    pub seed: u64,
    pub duration: Time,
    pub settle: Time,
    pub host: HostResources,
    pub cluster: ClusterShape,
    pub clients: ClientSettings,
    pub paths: Vec<LoadPath>,
    pub deadlines: RecoveryDeadlines,
    pub faults: Vec<FaultPlan>,
    pub self_check: Option<SelfCheck>,
    pub lifecycle: Option<Lifecycle>,
    pub disaster_recovery: Option<RecoveryObjectives>,
}

A sustained-load and failure contract.

Fields

name: String

profile: Profile

seed: u64

Seeds the fault-schedule jitter and the choice of an any target, so two runs of one contract inject the same faults at the same offsets.

duration: Time

Length of the load, from the first record to the start of reconciliation.

settle: Time

The fault-free tail at the end of the load. No fault may start or still be recovering inside it, so reconciliation reads a settled cluster.

host: HostResources

cluster: ClusterShape

clients: ClientSettings

paths: Vec<LoadPath>

deadlines: RecoveryDeadlines

faults: Vec<FaultPlan>

self_check: Option<SelfCheck>

lifecycle: Option<Lifecycle>

The release a lifecycle contract starts on. Left out of the encoding when absent, so the digest of a contract without one is unchanged.

disaster_recovery: Option<RecoveryObjectives>

The recovery objectives of a disaster-recovery drill. Omitted from the encoding when absent, so a soak’s digest does not change with it.

Implementations

impl Contract

pub fn from_yaml(text: &str) -> Result<Self, Error>

Parse a contract from YAML. This checks the shape only; call Self::validate before running or judging it.

Errors

Returns the parser’s error for a document that is not a contract.

pub fn from_file(path: &Path) -> Result<Self>

Read, parse and validate the contract at path.

Errors

Returns why the file cannot be read or parsed, or every reason Self::validate refuses it, one per line.

pub fn digest(&self) -> String

The SHA-256 of the contract’s canonical JSON encoding, as lowercase hex.

Evidence records this, and the judge refuses evidence whose digest differs. A name and a seed do not change when a budget or a deadline is edited after a run; this does.

pub fn path(&self, name: &str) -> Option<&LoadPath>

The path named name.

pub fn missing_coverage(&self) -> Vec<String>

The load paths, storage kinds and isolation levels the milestone names that this contract does not cover.

pub fn validate(&self) -> Vec<ContractError>

Every reason this contract cannot be run safely or judged honestly.

An empty list is a contract the harness will run. The fault schedule is expanded and checked here too, so a plan whose occurrences would overlap or run into the settle window is refused before the first record.

Trait Implementations

impl Clone for Contract

fn clone(&self) -> Contract

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Contract

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Contract

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Contract

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Contract

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 Contract