Skip to main content

delta_stream/
error.rs

1use std::fmt::{Display, Formatter};
2
3/// Errors returned by DeltaStream encoding, decoding, transport, and state application.
4#[derive(Debug)]
5pub enum DeltaError {
6    InvalidState(&'static str),
7    InvalidPacket(String),
8    Io(std::io::Error),
9    Json(serde_json::Error),
10    Compression(String),
11    Transport(String),
12    ResourceLimit(&'static str),
13    PacketTooLarge {
14        limit: usize,
15        actual: usize,
16    },
17    DecompressedPayloadTooLarge {
18        limit: usize,
19        actual: Option<usize>,
20    },
21    ChecksumMismatch {
22        expected: u32,
23        actual: u32,
24    },
25    ProtocolVersion {
26        received: u8,
27        supported: u8,
28    },
29    ProtocolVersionRange {
30        received: u8,
31        min_supported: u8,
32        max_supported: u8,
33    },
34    SchemaMismatch {
35        expected: u64,
36        received: u64,
37    },
38    SchemaMigrationMissing {
39        from: u64,
40        to: u64,
41    },
42}
43
44impl Display for DeltaError {
45    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
46        match self {
47            Self::InvalidState(msg) => write!(f, "invalid state: {msg}"),
48            Self::InvalidPacket(msg) => write!(f, "invalid packet: {msg}"),
49            Self::Io(err) => write!(f, "I/O error: {err}"),
50            Self::Json(err) => write!(f, "JSON error: {err}"),
51            Self::Compression(msg) => write!(f, "compression error: {msg}"),
52            Self::Transport(msg) => write!(f, "transport error: {msg}"),
53            Self::ResourceLimit(msg) => write!(f, "resource limit: {msg}"),
54            Self::PacketTooLarge { limit, actual } => {
55                write!(
56                    f,
57                    "packet too large: {actual} bytes exceeds limit {limit} bytes"
58                )
59            }
60            Self::DecompressedPayloadTooLarge {
61                limit,
62                actual: Some(actual),
63            } => write!(
64                f,
65                "decompressed payload too large: {actual} bytes exceeds limit {limit} bytes"
66            ),
67            Self::DecompressedPayloadTooLarge {
68                limit,
69                actual: None,
70            } => write!(f, "decompressed payload exceeds limit {limit} bytes"),
71            Self::ChecksumMismatch { expected, actual } => {
72                write!(
73                    f,
74                    "checksum mismatch: expected {expected:#010x}, got {actual:#010x}"
75                )
76            }
77            Self::ProtocolVersion {
78                received,
79                supported,
80            } => {
81                write!(
82                    f,
83                    "unsupported protocol version {received}; supported version is {supported}"
84                )
85            }
86            Self::ProtocolVersionRange {
87                received,
88                min_supported,
89                max_supported,
90            } => {
91                write!(f, "unsupported protocol version {received}; supported range is {min_supported}..={max_supported}")
92            }
93            Self::SchemaMismatch { expected, received } => {
94                write!(
95                    f,
96                    "schema mismatch: expected {expected:#x}, got {received:#x}"
97                )
98            }
99            Self::SchemaMigrationMissing { from, to } => {
100                write!(
101                    f,
102                    "no schema migration registered from {from:#x} to {to:#x}"
103                )
104            }
105        }
106    }
107}
108
109impl std::error::Error for DeltaError {}
110impl From<std::io::Error> for DeltaError {
111    fn from(value: std::io::Error) -> Self {
112        Self::Io(value)
113    }
114}
115impl From<serde_json::Error> for DeltaError {
116    fn from(value: serde_json::Error) -> Self {
117        Self::Json(value)
118    }
119}