cc-lb-plugin-conformance 0.1.1

cc-lb plugin conformance suite — in-process protocol verification helpers for external plugin authors.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use cc_lb_plugin_api::types::PluginSlot;
use cc_lb_plugin_wire::self_check::{
    SelfCheckStage as WireSelfCheckStage, SelfCheckStatus as WireSelfCheckStatus,
};
use cc_lb_runtime_protocol::self_check::{SelfCheckExecutionError, execute_self_check};
use thiserror::Error;

pub fn run(wasm: &[u8], supported_slots: &[PluginSlot]) -> Result<SelfCheckReport, SelfCheckError> {
    let response =
        execute_self_check(wasm, supported_slots).map_err(SelfCheckError::from_protocol)?;

    Ok(SelfCheckReport {
        status: response.status.into(),
        failures: response
            .failures
            .into_iter()
            .map(|failure| SelfCheckFailure {
                function: stage_name(failure.stage).to_owned(),
                version: 0,
                reason: failure.message,
            })
            .collect(),
    })
}

#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SelfCheckReport {
    pub status: SelfCheckStatus,
    pub failures: Vec<SelfCheckFailure>,
}

#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SelfCheckStatus {
    Success,
    Failure,
}

#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SelfCheckFailure {
    pub function: String,
    pub version: u32,
    pub reason: String,
}

#[non_exhaustive]
#[derive(Debug, Clone, Error, PartialEq, Eq)]
pub enum SelfCheckError {
    #[error("plugin instantiation failed: {reason}")]
    Instantiate { reason: String },
    #[error("plugin does not export cc_lb_self_check")]
    MissingExport,
    #[error("self-check reported failure status")]
    FailureStatus,
    #[error("self-check output invalid: {reason}")]
    Output { reason: String },
    #[error("wasm execution failed: {reason}")]
    WasmTrap { reason: String },
}

impl SelfCheckError {
    pub(crate) fn from_protocol(error: SelfCheckExecutionError) -> Self {
        let reason = error.to_string();
        match error {
            SelfCheckExecutionError::Instantiate { reason } => {
                SelfCheckError::Instantiate { reason }
            }
            SelfCheckExecutionError::MissingSelfCheckExport => SelfCheckError::MissingExport,
            SelfCheckExecutionError::Call { reason } => SelfCheckError::WasmTrap { reason },
            SelfCheckExecutionError::FailureStatus { .. } => SelfCheckError::FailureStatus,
            SelfCheckExecutionError::Validation(_)
            | SelfCheckExecutionError::SerializeRequest { .. }
            | SelfCheckExecutionError::OutputTooLarge { .. }
            | SelfCheckExecutionError::DecodeResponse { .. }
            | SelfCheckExecutionError::SuccessWithFailures { .. }
            | SelfCheckExecutionError::FailureWithoutFailures
            | SelfCheckExecutionError::Clock { .. } => SelfCheckError::Output { reason },
            _ => unreachable!(),
        }
    }
}

impl From<WireSelfCheckStatus> for SelfCheckStatus {
    fn from(status: WireSelfCheckStatus) -> Self {
        match status {
            WireSelfCheckStatus::Success => SelfCheckStatus::Success,
            WireSelfCheckStatus::Failure => SelfCheckStatus::Failure,
        }
    }
}

fn stage_name(stage: WireSelfCheckStage) -> &'static str {
    match stage {
        WireSelfCheckStage::RequestPreparation => "request_preparation",
        WireSelfCheckStage::WireFunctionTest => "wire_function_test",
        WireSelfCheckStage::CapabilityVerification => "capability_verification",
        WireSelfCheckStage::ResponseValidation => "response_validation",
    }
}