warg_api/v1/
monitor.rs

1//! Types relating to the monitor API.
2
3use serde::{Deserialize, Serialize, Serializer};
4use std::borrow::Cow;
5use thiserror::Error;
6
7/// Represents checkpoint verification response.
8#[derive(Serialize, Deserialize)]
9#[serde(rename_all = "camelCase")]
10pub struct CheckpointVerificationResponse {
11    /// The checkpoint verification state.
12    pub checkpoint: VerificationState,
13    /// The checkpoint signature verification state.
14    pub signature: VerificationState,
15    /// Optional, retry after specified number of seconds.
16    #[serde(skip_serializing_if = "Option::is_none")]
17    pub retry_after: Option<u16>,
18}
19
20/// Represents checkpoint verification state.
21#[derive(Eq, PartialEq, Debug, Serialize, Deserialize)]
22#[serde(rename_all = "camelCase")]
23pub enum VerificationState {
24    /// The checkpoint is unverified and could be valid or invalid.
25    #[serde(rename_all = "camelCase")]
26    Unverified,
27    /// The checkpoint is verified.
28    #[serde(rename_all = "camelCase")]
29    Verified,
30    /// The checkpoint is invalid.
31    #[serde(rename_all = "camelCase")]
32    Invalid,
33}
34
35/// Represents a monitor API error.
36#[non_exhaustive]
37#[derive(Debug, Error)]
38pub enum MonitorError {
39    /// An error with a message occurred.
40    #[error("{message}")]
41    Message {
42        /// The HTTP status code.
43        status: u16,
44        /// The error message
45        message: String,
46    },
47}
48
49impl MonitorError {
50    /// Returns the HTTP status code of the error.
51    pub fn status(&self) -> u16 {
52        match self {
53            Self::Message { status, .. } => *status,
54        }
55    }
56}
57
58#[derive(Serialize, Deserialize)]
59#[serde(untagged, rename_all = "camelCase")]
60enum RawError<'a> {
61    Message { status: u16, message: Cow<'a, str> },
62}
63
64impl Serialize for MonitorError {
65    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
66        match self {
67            Self::Message { status, message } => RawError::Message {
68                status: *status,
69                message: Cow::Borrowed(message),
70            }
71            .serialize(serializer),
72        }
73    }
74}
75
76impl<'de> Deserialize<'de> for MonitorError {
77    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
78    where
79        D: serde::Deserializer<'de>,
80    {
81        match RawError::deserialize(deserializer)? {
82            RawError::Message { status, message } => Ok(Self::Message {
83                status,
84                message: message.into_owned(),
85            }),
86        }
87    }
88}