1pub mod gRPCTransport;
32pub mod IPCTransport;
33pub mod Strategy;
34pub mod WASMTransport;
35
36use std::time::Duration;
37use anyhow::Result;
38pub const DEFAULT_CONNECTION_TIMEOUT_MS:u64 = 5000;
42
43pub const DEFAULT_REQUEST_TIMEOUT_MS:u64 = 30000;
45
46#[derive(Debug, Clone)]
48pub struct TransportConfig {
49 pub ConnectionTimeout: Duration,
51 pub RequestTimeout: Duration,
53 pub MaximumRetries: u32,
55 pub RetryDelay: Duration,
57 pub KeepaliveEnabled: bool,
59 pub KeepaliveInterval: Duration,
61}
62
63impl Default for TransportConfig {
64 fn default() -> Self {
65 Self {
66 ConnectionTimeout: Duration::from_millis(DEFAULT_CONNECTION_TIMEOUT_MS),
67 RequestTimeout: Duration::from_millis(DEFAULT_REQUEST_TIMEOUT_MS),
68 MaximumRetries: 3,
69 RetryDelay: Duration::from_millis(1000),
70 KeepaliveEnabled: true,
71 KeepaliveInterval: Duration::from_secs(30),
72 }
73 }
74}
75
76impl TransportConfig {
77 pub fn New() -> Self { Self::default() }
79
80 pub fn WithConnectionTimeout(mut self, Timeout: Duration) -> Self {
82 self.ConnectionTimeout = Timeout;
83 self
84 }
85
86 pub fn WithRequestTimeout(mut self, Timeout: Duration) -> Self {
88 self.RequestTimeout = Timeout;
89 self
90 }
91
92 pub fn WithMaximumRetries(mut self, MaximumRetries: u32) -> Self {
94 self.MaximumRetries = MaximumRetries;
95 self
96 }
97
98 pub fn WithRetryDelay(mut self, Delay: Duration) -> Self {
100 self.RetryDelay = Delay;
101 self
102 }
103
104 pub fn WithKeepalive(mut self, Enabled: bool) -> Self {
106 self.KeepaliveEnabled = Enabled;
107 self
108 }
109}
110
111pub fn CreateDefaultTransport() -> Strategy::Transport { Strategy::Transport::default() }
113
114pub fn CreategRPCTransport(Address: &str) -> Result<Strategy::Transport> {
116 Ok(Strategy::Transport::gRPC(gRPCTransport::gRPCTransport::New(Address)?))
117}
118
119pub fn CreateIPCTransport() -> Result<Strategy::Transport> {
121 Ok(Strategy::Transport::IPC(IPCTransport::IPCTransport::New()?))
122}
123
124pub fn CreateWASMTransport(
126 EnableWASI: bool,
127 MemoryLimitMegabytes: u64,
128 MaxExecutionTimeMilliseconds: u64,
129) -> Result<Strategy::Transport> {
130 Ok(Strategy::Transport::WASM(WASMTransport::WASMTransportImpl::new(
131 EnableWASI,
132 MemoryLimitMegabytes,
133 MaxExecutionTimeMilliseconds,
134 )?))
135}
136
137#[cfg(test)]
138mod tests {
139 use super::*;
140
141 #[test]
142 fn TestTransportConfigDefault() {
143 let Configuration = TransportConfig::default();
144 assert_eq!(
145 Configuration.ConnectionTimeout.as_millis(),
146 DEFAULT_CONNECTION_TIMEOUT_MS as u128
147 );
148 }
149
150 #[test]
151 fn TestTransportConfigBuilder() {
152 let Configuration = TransportConfig::default()
153 .WithConnectionTimeout(Duration::from_secs(10))
154 .WithMaximumRetries(5);
155
156 assert_eq!(Configuration.ConnectionTimeout.as_secs(), 10);
157 assert_eq!(Configuration.MaximumRetries, 5);
158 }
159
160 #[test]
161 fn TestTransportDefault() {
162 let TransportValue = CreateDefaultTransport();
163 match TransportValue {
164 Strategy::Transport::gRPC(_)
165 | Strategy::Transport::IPC(_)
166 | Strategy::Transport::WASM(_) => {},
167 }
168 }
169}