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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
use dataplane::core::{Encoder, Decoder};
#[derive(Debug, Default, Clone, PartialEq, Encoder, Decoder)]
#[cfg_attr(feature = "use_serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SmartModuleSpec {
pub input_kind: SmartModuleInputKind,
pub output_kind: SmartModuleOutputKind,
pub source_code: Option<SmartModuleSourceCode>,
pub wasm: SmartModuleWasm,
pub parameters: Option<Vec<SmartModuleParameter>>,
}
#[derive(Debug, Clone, Default, PartialEq, Encoder, Decoder)]
#[cfg_attr(feature = "use_serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SmartModuleSourceCode {
language: SmartModuleSourceCodeLanguage,
payload: String,
}
#[derive(Debug, Clone, PartialEq, Encoder, Decoder)]
#[cfg_attr(feature = "use_serde", derive(serde::Serialize, serde::Deserialize))]
pub enum SmartModuleSourceCodeLanguage {
Rust,
}
impl Default for SmartModuleSourceCodeLanguage {
fn default() -> SmartModuleSourceCodeLanguage {
SmartModuleSourceCodeLanguage::Rust
}
}
#[derive(Clone, Default, PartialEq, Encoder, Decoder)]
#[cfg_attr(feature = "use_serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SmartModuleWasm {
pub format: SmartModuleWasmFormat,
#[cfg_attr(feature = "use_serde", serde(with = "base64"))]
pub payload: Vec<u8>,
}
impl std::fmt::Debug for SmartModuleWasm {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(&format!(
"SmartModuleWasm {{ format: {:?}, payload: [REDACTED] }}",
self.format
))
}
}
#[cfg(feature = "use_serde")]
mod base64 {
use serde::{Serialize, Deserialize};
use serde::{Deserializer, Serializer};
#[allow(clippy::ptr_arg)]
pub fn serialize<S: Serializer>(v: &Vec<u8>, s: S) -> Result<S::Ok, S::Error> {
let base64 = base64::encode(v);
String::serialize(&base64, s)
}
pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Vec<u8>, D::Error> {
let base64 = String::deserialize(d)?;
base64::decode(base64.as_bytes()).map_err(serde::de::Error::custom)
}
}
impl SmartModuleWasm {
pub fn from_binary_payload(payload: Vec<u8>) -> Self {
SmartModuleWasm {
payload,
format: SmartModuleWasmFormat::Binary,
}
}
}
#[derive(Debug, Clone, PartialEq, Encoder, Decoder)]
#[cfg_attr(feature = "use_serde", derive(serde::Serialize, serde::Deserialize))]
pub enum SmartModuleWasmFormat {
#[cfg_attr(feature = "use_serde", serde(rename = "BINARY"))]
Binary,
#[cfg_attr(feature = "use_serde", serde(rename = "TEXT"))]
Text,
}
impl Default for SmartModuleWasmFormat {
fn default() -> SmartModuleWasmFormat {
SmartModuleWasmFormat::Binary
}
}
#[derive(Debug, Clone, Default, PartialEq, Encoder, Decoder)]
#[cfg_attr(feature = "use_serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SmartModuleParameter {
name: String,
}
#[derive(Debug, Clone, PartialEq, Encoder, Decoder)]
#[cfg_attr(feature = "use_serde", derive(serde::Serialize, serde::Deserialize))]
pub enum SmartModuleInputKind {
Stream,
External,
}
impl Default for SmartModuleInputKind {
fn default() -> SmartModuleInputKind {
SmartModuleInputKind::Stream
}
}
#[derive(Debug, Clone, PartialEq, Encoder, Decoder)]
#[cfg_attr(feature = "use_serde", derive(serde::Serialize, serde::Deserialize))]
pub enum SmartModuleOutputKind {
Stream,
External,
Table,
}
impl Default for SmartModuleOutputKind {
fn default() -> SmartModuleOutputKind {
SmartModuleOutputKind::Stream
}
}
impl std::fmt::Display for SmartModuleSpec {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "SmartModuleSpec")
}
}