itsi-scheduler 0.1.0 → 0.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (49) hide show
  1. checksums.yaml +4 -4
  2. data/Cargo.lock +219 -23
  3. data/Rakefile +7 -1
  4. data/ext/itsi_error/Cargo.toml +2 -0
  5. data/ext/itsi_error/src/from.rs +70 -0
  6. data/ext/itsi_error/src/lib.rs +10 -37
  7. data/ext/itsi_instrument_entry/Cargo.toml +15 -0
  8. data/ext/itsi_instrument_entry/src/lib.rs +31 -0
  9. data/ext/itsi_rb_helpers/Cargo.toml +2 -0
  10. data/ext/itsi_rb_helpers/src/heap_value.rs +121 -0
  11. data/ext/itsi_rb_helpers/src/lib.rs +90 -10
  12. data/ext/itsi_scheduler/Cargo.toml +9 -1
  13. data/ext/itsi_scheduler/extconf.rb +1 -1
  14. data/ext/itsi_scheduler/src/itsi_scheduler/io_helpers.rs +56 -0
  15. data/ext/itsi_scheduler/src/itsi_scheduler/io_waiter.rs +44 -0
  16. data/ext/itsi_scheduler/src/itsi_scheduler/timer.rs +44 -0
  17. data/ext/itsi_scheduler/src/itsi_scheduler.rs +308 -0
  18. data/ext/itsi_scheduler/src/lib.rs +31 -10
  19. data/ext/itsi_server/Cargo.toml +41 -0
  20. data/ext/itsi_server/extconf.rb +6 -0
  21. data/ext/itsi_server/src/body_proxy/big_bytes.rs +104 -0
  22. data/ext/itsi_server/src/body_proxy/itsi_body_proxy.rs +122 -0
  23. data/ext/itsi_server/src/body_proxy/mod.rs +2 -0
  24. data/ext/itsi_server/src/lib.rs +103 -0
  25. data/ext/itsi_server/src/request/itsi_request.rs +277 -0
  26. data/ext/itsi_server/src/request/mod.rs +1 -0
  27. data/ext/itsi_server/src/response/itsi_response.rs +347 -0
  28. data/ext/itsi_server/src/response/mod.rs +1 -0
  29. data/ext/itsi_server/src/server/bind.rs +168 -0
  30. data/ext/itsi_server/src/server/bind_protocol.rs +37 -0
  31. data/ext/itsi_server/src/server/io_stream.rs +104 -0
  32. data/ext/itsi_server/src/server/itsi_ca/itsi_ca.crt +13 -0
  33. data/ext/itsi_server/src/server/itsi_ca/itsi_ca.key +5 -0
  34. data/ext/itsi_server/src/server/itsi_server.rs +230 -0
  35. data/ext/itsi_server/src/server/lifecycle_event.rs +8 -0
  36. data/ext/itsi_server/src/server/listener.rs +259 -0
  37. data/ext/itsi_server/src/server/mod.rs +11 -0
  38. data/ext/itsi_server/src/server/process_worker.rs +196 -0
  39. data/ext/itsi_server/src/server/serve_strategy/cluster_mode.rs +253 -0
  40. data/ext/itsi_server/src/server/serve_strategy/mod.rs +27 -0
  41. data/ext/itsi_server/src/server/serve_strategy/single_mode.rs +238 -0
  42. data/ext/itsi_server/src/server/signal.rs +57 -0
  43. data/ext/itsi_server/src/server/thread_worker.rs +368 -0
  44. data/ext/itsi_server/src/server/tls.rs +152 -0
  45. data/ext/itsi_tracing/Cargo.toml +4 -0
  46. data/ext/itsi_tracing/src/lib.rs +36 -6
  47. data/lib/itsi/scheduler/version.rb +1 -1
  48. data/lib/itsi/scheduler.rb +137 -1
  49. metadata +38 -4
@@ -0,0 +1,347 @@
1
+ use bytes::{Bytes, BytesMut};
2
+ use derive_more::Debug;
3
+ use futures::stream::{unfold, StreamExt};
4
+ use http::{
5
+ header::TRANSFER_ENCODING, request::Parts, HeaderMap, HeaderName, HeaderValue, Request,
6
+ Response, StatusCode,
7
+ };
8
+ use http_body_util::{combinators::BoxBody, Empty, Full, StreamBody};
9
+ use hyper::{body::Frame, upgrade::Upgraded};
10
+ use hyper_util::rt::TokioIo;
11
+ use itsi_error::Result;
12
+ use itsi_tracing::error;
13
+ use magnus::error::Result as MagnusResult;
14
+ use parking_lot::RwLock;
15
+ use std::{
16
+ convert::Infallible,
17
+ io,
18
+ os::{fd::FromRawFd, unix::net::UnixStream},
19
+ str::FromStr,
20
+ sync::Arc,
21
+ };
22
+ use tokio::{
23
+ io::AsyncReadExt,
24
+ net::UnixStream as TokioUnixStream,
25
+ sync::{
26
+ mpsc::{self},
27
+ watch,
28
+ },
29
+ };
30
+ use tokio_stream::wrappers::ReceiverStream;
31
+ use tokio_util::io::ReaderStream;
32
+ use tracing::warn;
33
+
34
+ use crate::server::serve_strategy::single_mode::RunningPhase;
35
+
36
+ #[magnus::wrap(class = "Itsi::Response", free_immediately, size)]
37
+ #[derive(Debug, Clone)]
38
+ pub struct ItsiResponse {
39
+ pub data: Arc<ResponseData>,
40
+ }
41
+
42
+ #[derive(Debug)]
43
+ pub struct ResponseData {
44
+ pub response: RwLock<Option<Response<BoxBody<Bytes, Infallible>>>>,
45
+ pub response_writer: RwLock<Option<mpsc::Sender<Option<Bytes>>>>,
46
+ pub response_buffer: RwLock<BytesMut>,
47
+ pub hijacked_socket: RwLock<Option<UnixStream>>,
48
+ pub parts: Parts,
49
+ }
50
+
51
+ impl ItsiResponse {
52
+ pub async fn build(
53
+ &self,
54
+ first_frame: Option<Bytes>,
55
+ receiver: mpsc::Receiver<Option<Bytes>>,
56
+ shutdown_rx: watch::Receiver<RunningPhase>,
57
+ ) -> Response<BoxBody<Bytes, Infallible>> {
58
+ if self.is_hijacked() {
59
+ return match self.process_hijacked_response().await {
60
+ Ok(result) => result,
61
+ Err(e) => {
62
+ error!("Error processing hijacked response: {}", e);
63
+ Response::new(BoxBody::new(Empty::new()))
64
+ }
65
+ };
66
+ }
67
+
68
+ let mut response = self.data.response.write().take().unwrap();
69
+ *response.body_mut() = if first_frame.is_none() {
70
+ BoxBody::new(Empty::new())
71
+ } else if receiver.is_closed() && receiver.is_empty() {
72
+ BoxBody::new(Full::new(first_frame.unwrap()))
73
+ } else {
74
+ let initial_frame = tokio_stream::once(Ok(Frame::data(first_frame.unwrap())));
75
+ let frame_stream = unfold(
76
+ (ReceiverStream::new(receiver), shutdown_rx),
77
+ |(mut receiver, mut shutdown_rx)| async move {
78
+ if let RunningPhase::ShutdownPending = *shutdown_rx.borrow() {
79
+ warn!("Disconnecting streaming client.");
80
+ return None;
81
+ }
82
+ loop {
83
+ tokio::select! {
84
+ maybe_bytes = receiver.next() => {
85
+ if let Some(bytes) = maybe_bytes {
86
+ // We assume `bytes` is Some(Bytes) here.
87
+ return Some((Ok(Frame::data(bytes.unwrap())), (receiver, shutdown_rx)));
88
+ } else {
89
+ // Receiver closed, end the stream.
90
+ return None;
91
+ }
92
+ },
93
+ _ = shutdown_rx.changed() => {
94
+ match *shutdown_rx.borrow() {
95
+ RunningPhase::ShutdownPending => {
96
+ warn!("Disconnecting streaming client.");
97
+ return None;
98
+ },
99
+ _ => continue,
100
+ }
101
+ }
102
+ }
103
+ }
104
+ },
105
+ );
106
+
107
+ let combined_stream = initial_frame.chain(frame_stream);
108
+ BoxBody::new(StreamBody::new(combined_stream))
109
+ };
110
+ response
111
+ }
112
+
113
+ pub fn close(&self) {
114
+ self.data.response_writer.write().take();
115
+ }
116
+
117
+ async fn two_way_bridge(upgraded: Upgraded, local: TokioUnixStream) -> io::Result<()> {
118
+ let client_io = TokioIo::new(upgraded);
119
+
120
+ // Split each side
121
+ let (mut lr, mut lw) = tokio::io::split(local);
122
+ let (mut cr, mut cw) = tokio::io::split(client_io);
123
+
124
+ let to_ruby = tokio::spawn(async move {
125
+ if let Err(e) = tokio::io::copy(&mut cr, &mut lw).await {
126
+ eprintln!("Error copying upgraded->local: {:?}", e);
127
+ }
128
+ });
129
+ let from_ruby = tokio::spawn(async move {
130
+ if let Err(e) = tokio::io::copy(&mut lr, &mut cw).await {
131
+ eprintln!("Error copying upgraded->local: {:?}", e);
132
+ }
133
+ });
134
+
135
+ let _ = to_ruby.await;
136
+ let _ = from_ruby.await;
137
+ Ok(())
138
+ }
139
+
140
+ async fn read_response_headers(&self, reader: &mut TokioUnixStream) -> Result<Vec<u8>> {
141
+ let mut buf = [0u8; 1];
142
+ let mut collected = Vec::new();
143
+ loop {
144
+ let n = reader.read(&mut buf).await?;
145
+ if n == 0 {
146
+ // EOF reached unexpectedly
147
+ break;
148
+ }
149
+ collected.push(buf[0]);
150
+ if collected.ends_with(b"\r\n\r\n") {
151
+ break;
152
+ }
153
+ }
154
+
155
+ Ok(collected)
156
+ }
157
+
158
+ pub async fn read_hijacked_headers(
159
+ &self,
160
+ ) -> Result<(HeaderMap, StatusCode, bool, TokioUnixStream)> {
161
+ let hijacked_socket =
162
+ self.data
163
+ .hijacked_socket
164
+ .write()
165
+ .take()
166
+ .ok_or(itsi_error::ItsiError::InvalidInput(
167
+ "Couldn't hijack stream".to_owned(),
168
+ ))?;
169
+ let mut reader = TokioUnixStream::from_std(hijacked_socket).unwrap();
170
+ let response_headers = self.read_response_headers(&mut reader).await?;
171
+ let mut headers = [httparse::EMPTY_HEADER; 64];
172
+ let mut resp = httparse::Response::new(&mut headers);
173
+ resp.parse(&response_headers)?;
174
+
175
+ let status = StatusCode::from_u16(resp.code.unwrap_or(200)).unwrap_or(StatusCode::OK);
176
+ let mut headers = HeaderMap::new();
177
+ for header in resp.headers.iter() {
178
+ headers.insert(
179
+ HeaderName::from_str(header.name).unwrap(),
180
+ HeaderValue::from_bytes(header.value).unwrap(),
181
+ );
182
+ }
183
+ let requires_upgrade = status == StatusCode::SWITCHING_PROTOCOLS;
184
+ Ok((headers, status, requires_upgrade, reader))
185
+ }
186
+
187
+ pub async fn process_hijacked_response(&self) -> Result<Response<BoxBody<Bytes, Infallible>>> {
188
+ let (headers, status, requires_upgrade, reader) = self.read_hijacked_headers().await?;
189
+ let mut response = if requires_upgrade {
190
+ let parts = self.data.parts.clone();
191
+ tokio::spawn(async move {
192
+ let mut req = Request::from_parts(parts, Empty::<Bytes>::new());
193
+ match hyper::upgrade::on(&mut req).await {
194
+ Ok(upgraded) => {
195
+ Self::two_way_bridge(upgraded, reader)
196
+ .await
197
+ .expect("Error in creating two way bridge");
198
+ }
199
+ Err(e) => eprintln!("upgrade error: {:?}", e),
200
+ }
201
+ });
202
+ Response::new(BoxBody::new(Empty::new()))
203
+ } else {
204
+ let stream = ReaderStream::new(reader);
205
+ let boxed_body = if headers
206
+ .get(TRANSFER_ENCODING)
207
+ .is_some_and(|h| h == "chunked")
208
+ {
209
+ BoxBody::new(StreamBody::new(unfold(
210
+ (stream, Vec::new()),
211
+ |(mut stream, mut buf)| async move {
212
+ loop {
213
+ if let Some(pos) = buf.iter().position(|&b| b == b'\n') {
214
+ let line = buf.drain(..=pos).collect::<Vec<u8>>();
215
+ let line = std::str::from_utf8(&line).ok()?.trim();
216
+ let chunk_size = usize::from_str_radix(line, 16).ok()?;
217
+ if chunk_size == 0 {
218
+ return None;
219
+ }
220
+ while buf.len() < chunk_size {
221
+ match stream.next().await {
222
+ Some(Ok(chunk)) => buf.extend_from_slice(&chunk),
223
+ _ => return None,
224
+ }
225
+ }
226
+ let data = buf.drain(..chunk_size).collect::<Vec<u8>>();
227
+ if buf.starts_with(b"\r\n") {
228
+ buf.drain(..2);
229
+ }
230
+ return Some((Ok(Frame::data(Bytes::from(data))), (stream, buf)));
231
+ }
232
+ match stream.next().await {
233
+ Some(Ok(chunk)) => buf.extend_from_slice(&chunk),
234
+ _ => return None,
235
+ }
236
+ }
237
+ },
238
+ )))
239
+ } else {
240
+ BoxBody::new(StreamBody::new(stream.map(
241
+ |result: std::result::Result<Bytes, io::Error>| {
242
+ result
243
+ .map(Frame::data)
244
+ .map_err(|e| unreachable!("unexpected io error: {:?}", e))
245
+ },
246
+ )))
247
+ };
248
+ Response::new(boxed_body)
249
+ };
250
+
251
+ *response.status_mut() = status;
252
+ *response.headers_mut() = headers;
253
+ Ok(response)
254
+ }
255
+
256
+ pub fn internal_server_error(&self, message: String) {
257
+ error!(message);
258
+ self.data.response_writer.write().take();
259
+ if let Some(ref mut response) = *self.data.response.write() {
260
+ *response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
261
+ }
262
+ }
263
+
264
+ pub fn send_frame(&self, frame: Bytes) -> MagnusResult<usize> {
265
+ self.send_frame_into(frame, &self.data.response_writer)
266
+ }
267
+
268
+ pub fn send_and_close(&self, frame: Bytes) -> MagnusResult<usize> {
269
+ let result = self.send_frame_into(frame, &self.data.response_writer);
270
+ self.data.response_writer.write().take();
271
+ result
272
+ }
273
+
274
+ pub fn send_frame_into(
275
+ &self,
276
+ frame: Bytes,
277
+ writer: &RwLock<Option<mpsc::Sender<Option<Bytes>>>>,
278
+ ) -> MagnusResult<usize> {
279
+ if let Some(writer) = writer.write().as_ref() {
280
+ writer
281
+ .blocking_send(Some(frame))
282
+ .map_err(|_| itsi_error::ItsiError::ClientConnectionClosed)?;
283
+ }
284
+ Ok(0)
285
+ }
286
+
287
+ pub fn is_hijacked(&self) -> bool {
288
+ self.data.hijacked_socket.read().is_some()
289
+ }
290
+
291
+ pub fn close_write(&self) -> MagnusResult<bool> {
292
+ self.data.response_writer.write().take();
293
+ Ok(true)
294
+ }
295
+
296
+ pub fn close_read(&self) -> MagnusResult<bool> {
297
+ todo!();
298
+ }
299
+
300
+ pub fn new(parts: Parts, response_writer: mpsc::Sender<Option<Bytes>>) -> Self {
301
+ Self {
302
+ data: Arc::new(ResponseData {
303
+ response: RwLock::new(Some(Response::new(BoxBody::new(Empty::new())))),
304
+ response_writer: RwLock::new(Some(response_writer)),
305
+ response_buffer: RwLock::new(BytesMut::new()),
306
+ hijacked_socket: RwLock::new(None),
307
+ parts,
308
+ }),
309
+ }
310
+ }
311
+
312
+ pub fn add_header(&self, name: Bytes, value: Bytes) -> MagnusResult<()> {
313
+ let header_name: HeaderName = HeaderName::from_bytes(&name).map_err(|e| {
314
+ itsi_error::ItsiError::InvalidInput(format!("Invalid header name {:?}: {:?}", name, e))
315
+ })?;
316
+ let header_value = unsafe { HeaderValue::from_maybe_shared_unchecked(value) };
317
+ if let Some(ref mut resp) = *self.data.response.write() {
318
+ resp.headers_mut().insert(header_name, header_value);
319
+ }
320
+ Ok(())
321
+ }
322
+
323
+ pub fn set_status(&self, status: u16) -> MagnusResult<()> {
324
+ if let Some(ref mut resp) = *self.data.response.write() {
325
+ *resp.status_mut() = StatusCode::from_u16(status).map_err(|e| {
326
+ itsi_error::ItsiError::InvalidInput(format!(
327
+ "Invalid status code {:?}: {:?}",
328
+ status, e
329
+ ))
330
+ })?;
331
+ }
332
+ Ok(())
333
+ }
334
+
335
+ pub fn hijack(&self, fd: i32) -> MagnusResult<()> {
336
+ let stream = unsafe { UnixStream::from_raw_fd(fd) };
337
+
338
+ *self.data.hijacked_socket.write() = Some(stream);
339
+ if let Some(writer) = self.data.response_writer.write().as_ref() {
340
+ writer
341
+ .blocking_send(None)
342
+ .map_err(|_| itsi_error::ItsiError::ClientConnectionClosed)?;
343
+ }
344
+ self.close();
345
+ Ok(())
346
+ }
347
+ }
@@ -0,0 +1 @@
1
+ pub mod itsi_response;
@@ -0,0 +1,168 @@
1
+ use super::{bind_protocol::BindProtocol, tls::configure_tls};
2
+ use itsi_error::ItsiError;
3
+ use std::{
4
+ collections::HashMap,
5
+ net::{IpAddr, Ipv4Addr, Ipv6Addr, ToSocketAddrs},
6
+ path::PathBuf,
7
+ str::FromStr,
8
+ };
9
+ use tokio_rustls::rustls::ServerConfig;
10
+
11
+ #[derive(Debug, Clone)]
12
+ pub enum BindAddress {
13
+ Ip(IpAddr),
14
+ UnixSocket(PathBuf),
15
+ }
16
+
17
+ impl Default for BindAddress {
18
+ fn default() -> Self {
19
+ BindAddress::Ip(IpAddr::V4(Ipv4Addr::UNSPECIFIED))
20
+ }
21
+ }
22
+
23
+ #[derive(Default, Clone)]
24
+ #[magnus::wrap(class = "Itsi::Bind")]
25
+ pub struct Bind {
26
+ pub address: BindAddress,
27
+ pub port: Option<u16>, // None for Unix Sockets
28
+ pub protocol: BindProtocol,
29
+ pub tls_config: Option<ServerConfig>,
30
+ }
31
+
32
+ impl std::fmt::Debug for Bind {
33
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
34
+ match &self.address {
35
+ BindAddress::Ip(ip) => match self.protocol {
36
+ BindProtocol::Unix | BindProtocol::Unixs => {
37
+ write!(f, "{}://{}", self.protocol, ip)
38
+ }
39
+ BindProtocol::Https if self.port == Some(443) => {
40
+ write!(f, "{}://{}", self.protocol, ip)
41
+ }
42
+ BindProtocol::Http if self.port == Some(80) => {
43
+ write!(f, "{}://{}", self.protocol, ip)
44
+ }
45
+ _ => match self.port {
46
+ Some(port) => write!(f, "{}://{}:{}", self.protocol, ip, port),
47
+ None => write!(f, "{}://{}", self.protocol, ip),
48
+ },
49
+ },
50
+ BindAddress::UnixSocket(path) => {
51
+ write!(f, "{}://{}", self.protocol, path.display())
52
+ }
53
+ }
54
+ }
55
+ }
56
+
57
+ /// We can build a Bind from a string in the format `protocol://host:port?options`
58
+ /// E.g.
59
+ /// *`https://example.com:443?tls_cert=/path/to/cert.pem&tls_key=/path/to/key.pem`
60
+ /// *`unix:///path/to/socket.sock`
61
+ /// *`http://example.com:80`
62
+ /// *`https://[::]:80`
63
+ impl FromStr for Bind {
64
+ type Err = ItsiError;
65
+
66
+ fn from_str(s: &str) -> Result<Self, Self::Err> {
67
+ let (protocol, remainder) = if let Some((proto, rest)) = s.split_once("://") {
68
+ (proto.parse::<BindProtocol>()?, rest)
69
+ } else {
70
+ (BindProtocol::Https, s)
71
+ };
72
+
73
+ let (url, options) = if let Some((base, options)) = remainder.split_once('?') {
74
+ (base, parse_bind_options(options))
75
+ } else {
76
+ (remainder, HashMap::new())
77
+ };
78
+
79
+ let (host, port) = if url.starts_with('[') {
80
+ // IPv6 with brackets `[::]:port`
81
+ if let Some(end) = url.find(']') {
82
+ let host = &url[1..end]; // Extract `::`
83
+ let port = url[end + 1..]
84
+ .strip_prefix(':')
85
+ .and_then(|p| p.parse().ok());
86
+ (host, port)
87
+ } else {
88
+ return Err(ItsiError::InvalidInput(
89
+ "Invalid IPv6 address format".to_owned(),
90
+ ));
91
+ }
92
+ } else if let Some((h, p)) = url.rsplit_once(':') {
93
+ // Check if `h` is an IPv6 address before assuming it's a port
94
+ if h.contains('.') || h.parse::<Ipv4Addr>().is_ok() {
95
+ (h, p.parse::<u16>().ok()) // IPv4 case
96
+ } else if h.parse::<Ipv6Addr>().is_ok() {
97
+ // If it's IPv6, require brackets for port
98
+ return Err(ItsiError::InvalidInput(
99
+ "IPv6 addresses must use [ ] when specifying a port".to_owned(),
100
+ ));
101
+ } else {
102
+ (h, None) // Treat as a hostname
103
+ }
104
+ } else {
105
+ (url, None)
106
+ };
107
+
108
+ let address = if let Ok(ip) = host.parse::<IpAddr>() {
109
+ BindAddress::Ip(ip)
110
+ } else {
111
+ resolve_hostname(host)
112
+ .map(BindAddress::Ip)
113
+ .ok_or(ItsiError::ArgumentError(format!(
114
+ "Failed to resolve hostname {}",
115
+ host
116
+ )))?
117
+ };
118
+ let (port, address) = match protocol {
119
+ BindProtocol::Http => (port.or(Some(80)), address),
120
+ BindProtocol::Https => (port.or(Some(443)), address),
121
+ BindProtocol::Unix => (None, BindAddress::UnixSocket(host.into())),
122
+ BindProtocol::Unixs => (None, BindAddress::UnixSocket(host.into())),
123
+ };
124
+
125
+ let tls_config = match protocol {
126
+ BindProtocol::Http => None,
127
+ BindProtocol::Https => Some(configure_tls(host, &options)?),
128
+ BindProtocol::Unix => None,
129
+ BindProtocol::Unixs => Some(configure_tls(host, &options)?),
130
+ };
131
+
132
+ Ok(Self {
133
+ address,
134
+ port,
135
+ protocol,
136
+ tls_config,
137
+ })
138
+ }
139
+ }
140
+
141
+ fn parse_bind_options(query: &str) -> HashMap<String, String> {
142
+ query
143
+ .split('&')
144
+ .filter_map(|pair| pair.split_once('='))
145
+ .map(|(k, v)| (k.to_owned(), v.to_owned()))
146
+ .collect()
147
+ }
148
+
149
+ /// Attempts to resolve a hostname into an IP address.
150
+ fn resolve_hostname(hostname: &str) -> Option<IpAddr> {
151
+ (hostname, 0)
152
+ .to_socket_addrs()
153
+ .ok()?
154
+ .find_map(|addr| {
155
+ if addr.is_ipv6() {
156
+ Some(addr.ip()) // Prefer IPv6
157
+ } else {
158
+ None
159
+ }
160
+ })
161
+ .or_else(|| {
162
+ (hostname, 0)
163
+ .to_socket_addrs()
164
+ .ok()?
165
+ .map(|addr| addr.ip())
166
+ .next()
167
+ }) // Fallback to IPv4
168
+ }
@@ -0,0 +1,37 @@
1
+ use itsi_error::ItsiError;
2
+ use std::str::FromStr;
3
+
4
+ #[derive(Debug, Default, Clone)]
5
+ pub enum BindProtocol {
6
+ #[default]
7
+ Https,
8
+ Http,
9
+ Unix,
10
+ Unixs,
11
+ }
12
+
13
+ impl FromStr for BindProtocol {
14
+ type Err = ItsiError;
15
+
16
+ fn from_str(s: &str) -> Result<Self, Self::Err> {
17
+ match s {
18
+ "http" => Ok(BindProtocol::Http),
19
+ "https" => Ok(BindProtocol::Https),
20
+ "unix" => Ok(BindProtocol::Unix),
21
+ "tls" => Ok(BindProtocol::Unixs),
22
+ _ => Err(ItsiError::UnsupportedProtocol(s.to_string())),
23
+ }
24
+ }
25
+ }
26
+
27
+ impl std::fmt::Display for BindProtocol {
28
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
29
+ let s = match self {
30
+ BindProtocol::Https => "https",
31
+ BindProtocol::Http => "http",
32
+ BindProtocol::Unix => "unix",
33
+ BindProtocol::Unixs => "tls",
34
+ };
35
+ write!(f, "{}", s)
36
+ }
37
+ }
@@ -0,0 +1,104 @@
1
+ use super::listener::SockAddr;
2
+ use pin_project::pin_project;
3
+ use tokio::net::{TcpStream, UnixStream};
4
+ use tokio_rustls::server::TlsStream;
5
+
6
+ use std::os::unix::io::{AsRawFd, RawFd};
7
+ use std::pin::Pin;
8
+ use std::task::{Context, Poll};
9
+ use tokio::io::{AsyncRead, AsyncWrite};
10
+
11
+ #[pin_project(project = IoStreamEnumProj)]
12
+ pub enum IoStream {
13
+ Tcp {
14
+ #[pin]
15
+ stream: TcpStream,
16
+ addr: SockAddr,
17
+ },
18
+ TcpTls {
19
+ #[pin]
20
+ stream: TlsStream<TcpStream>,
21
+ addr: SockAddr,
22
+ },
23
+ Unix {
24
+ #[pin]
25
+ stream: UnixStream,
26
+ addr: SockAddr,
27
+ },
28
+ UnixTls {
29
+ #[pin]
30
+ stream: TlsStream<UnixStream>,
31
+ addr: SockAddr,
32
+ },
33
+ }
34
+
35
+ impl IoStream {
36
+ pub fn addr(&self) -> SockAddr {
37
+ match self {
38
+ IoStream::Tcp { addr, .. } => addr.clone(),
39
+ IoStream::TcpTls { addr, .. } => addr.clone(),
40
+ IoStream::Unix { addr, .. } => addr.clone(),
41
+ IoStream::UnixTls { addr, .. } => addr.clone(),
42
+ }
43
+ }
44
+ }
45
+
46
+ impl AsyncRead for IoStream {
47
+ fn poll_read(
48
+ self: Pin<&mut Self>,
49
+ cx: &mut Context<'_>,
50
+ buf: &mut tokio::io::ReadBuf<'_>,
51
+ ) -> Poll<std::io::Result<()>> {
52
+ match self.project() {
53
+ IoStreamEnumProj::Tcp { stream, .. } => stream.poll_read(cx, buf),
54
+ IoStreamEnumProj::TcpTls { stream, .. } => stream.poll_read(cx, buf),
55
+ IoStreamEnumProj::Unix { stream, .. } => stream.poll_read(cx, buf),
56
+ IoStreamEnumProj::UnixTls { stream, .. } => stream.poll_read(cx, buf),
57
+ }
58
+ }
59
+ }
60
+
61
+ impl AsyncWrite for IoStream {
62
+ fn poll_write(
63
+ self: Pin<&mut Self>,
64
+ cx: &mut Context<'_>,
65
+ buf: &[u8],
66
+ ) -> Poll<std::io::Result<usize>> {
67
+ match self.project() {
68
+ IoStreamEnumProj::Tcp { stream, .. } => stream.poll_write(cx, buf),
69
+ IoStreamEnumProj::TcpTls { stream, .. } => stream.poll_write(cx, buf),
70
+ IoStreamEnumProj::Unix { stream, .. } => stream.poll_write(cx, buf),
71
+ IoStreamEnumProj::UnixTls { stream, .. } => stream.poll_write(cx, buf),
72
+ }
73
+ }
74
+
75
+ fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
76
+ match self.project() {
77
+ IoStreamEnumProj::Tcp { stream, .. } => stream.poll_flush(cx),
78
+ IoStreamEnumProj::TcpTls { stream, .. } => stream.poll_flush(cx),
79
+ IoStreamEnumProj::Unix { stream, .. } => stream.poll_flush(cx),
80
+ IoStreamEnumProj::UnixTls { stream, .. } => stream.poll_flush(cx),
81
+ }
82
+ }
83
+
84
+ fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
85
+ match self.project() {
86
+ IoStreamEnumProj::Tcp { stream, .. } => stream.poll_shutdown(cx),
87
+ IoStreamEnumProj::TcpTls { stream, .. } => stream.poll_shutdown(cx),
88
+ IoStreamEnumProj::Unix { stream, .. } => stream.poll_shutdown(cx),
89
+ IoStreamEnumProj::UnixTls { stream, .. } => stream.poll_shutdown(cx),
90
+ }
91
+ }
92
+ }
93
+
94
+ impl AsRawFd for IoStream {
95
+ fn as_raw_fd(&self) -> RawFd {
96
+ // For immutable access, we can simply pattern-match on self.
97
+ match self {
98
+ IoStream::Tcp { stream, .. } => stream.as_raw_fd(),
99
+ IoStream::TcpTls { stream, .. } => stream.get_ref().0.as_raw_fd(),
100
+ IoStream::Unix { stream, .. } => stream.as_raw_fd(),
101
+ IoStream::UnixTls { stream, .. } => stream.get_ref().0.as_raw_fd(),
102
+ }
103
+ }
104
+ }
@@ -0,0 +1,13 @@
1
+ -----BEGIN CERTIFICATE-----
2
+ MIIB9TCCAZugAwIBAgIUMpQtAScU2Ow9c1Xy/0b/kS/BuwcwCgYIKoZIzj0EAwIw
3
+ UDELMAkGA1UEBhMCVVMxDTALBgNVBAgMBEl0c2kxDTALBgNVBAcMBEl0c2kxEDAO
4
+ BgNVBAoMB0l0c2kgQ0ExETAPBgNVBAMMCGl0c2kuZnlpMB4XDTI1MDMwMzIwMjg1
5
+ N1oXDTM1MDMwMTIwMjg1N1owUDELMAkGA1UEBhMCVVMxDTALBgNVBAgMBEl0c2kx
6
+ DTALBgNVBAcMBEl0c2kxEDAOBgNVBAoMB0l0c2kgQ0ExETAPBgNVBAMMCGl0c2ku
7
+ ZnlpMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEqGdC9Vi1r7ARvqSkPXkAgiV5
8
+ gn2MMTeEafagrWT7G1onSh/G+Qstxl61kfFNLOTiy6NSgAtKG+gfveCTo0Pcz6NT
9
+ MFEwHQYDVR0OBBYEFN7zzDodmiK2VAzLDydDvb6Er+U+MB8GA1UdIwQYMBaAFN7z
10
+ zDodmiK2VAzLDydDvb6Er+U+MA8GA1UdEwEB/wQFMAMBAf8wCgYIKoZIzj0EAwID
11
+ SAAwRQIhAP8q3PiwqTwCbRvYvvetxH39mAce1mfQMosb33ns228VAiBXdb+p9s0o
12
+ 5ug5g9/MTvrIPI7GgolXCWZunkouy0LSrw==
13
+ -----END CERTIFICATE-----
@@ -0,0 +1,5 @@
1
+ -----BEGIN PRIVATE KEY-----
2
+ MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgC7WOxDmO7pBvDvYn
3
+ YI8+z2/2c0ChxBsuJkQq/dXi1RyhRANCAASoZ0L1WLWvsBG+pKQ9eQCCJXmCfYwx
4
+ N4Rp9qCtZPsbWidKH8b5Cy3GXrWR8U0s5OLLo1KAC0ob6B+94JOjQ9zP
5
+ -----END PRIVATE KEY-----