itsi 0.1.9 → 0.1.12

data/crates/itsi_server/src/{response/itsi_response.rs → ruby_types/itsi_http_response.rs}

@@ -13,7 +13,7 @@ use itsi_tracing::error;
 use magnus::error::Result as MagnusResult;
 use parking_lot::RwLock;
 use std::{
-    convert::Infallible,
+    collections::HashMap,
     io,
     os::{fd::FromRawFd, unix::net::UnixStream},
     str::FromStr,
@@ -31,31 +31,32 @@ use tokio_stream::wrappers::ReceiverStream;
 use tokio_util::io::ReaderStream;
 use tracing::warn;
 
-use crate::server::serve_strategy::single_mode::RunningPhase;
+use crate::server::{
+    byte_frame::ByteFrame, serve_strategy::single_mode::RunningPhase, types::HttpResponse,
+};
 
-#[magnus::wrap(class = "Itsi::Response", free_immediately, size)]
+#[magnus::wrap(class = "Itsi::HttpResponse", free_immediately, size)]
 #[derive(Debug, Clone)]
-pub struct ItsiResponse {
+pub struct ItsiHttpResponse {
     pub data: Arc<ResponseData>,
-    pub accept: String,
 }
 
 #[derive(Debug)]
 pub struct ResponseData {
-    pub response: RwLock<Option<Response<BoxBody<Bytes, Infallible>>>>,
-    pub response_writer: RwLock<Option<mpsc::Sender<Option<Bytes>>>>,
+    pub response: RwLock<Option<HttpResponse>>,
+    pub response_writer: RwLock<Option<mpsc::Sender<ByteFrame>>>,
     pub response_buffer: RwLock<BytesMut>,
     pub hijacked_socket: RwLock<Option<UnixStream>>,
     pub parts: Parts,
 }
 
-impl ItsiResponse {
+impl ItsiHttpResponse {
     pub async fn build(
         &self,
-        first_frame: Option<Bytes>,
-        receiver: mpsc::Receiver<Option<Bytes>>,
+        first_frame: ByteFrame,
+        receiver: mpsc::Receiver<ByteFrame>,
         shutdown_rx: watch::Receiver<RunningPhase>,
-    ) -> Response<BoxBody<Bytes, Infallible>> {
+    ) -> HttpResponse {
         if self.is_hijacked() {
             return match self.process_hijacked_response().await {
                 Ok(result) => result,
@@ -65,31 +66,30 @@ impl ItsiResponse {
                 }
             };
         }
-
         let mut response = self.data.response.write().take().unwrap();
-        *response.body_mut() = if first_frame.is_none() {
+        *response.body_mut() = if matches!(first_frame, ByteFrame::Empty) {
             BoxBody::new(Empty::new())
-        } else if receiver.is_closed() && receiver.is_empty() {
-            BoxBody::new(Full::new(first_frame.unwrap()))
+        } else if matches!(first_frame, ByteFrame::End(_)) {
+            BoxBody::new(Full::new(first_frame.into()))
         } else {
-            let initial_frame = tokio_stream::once(Ok(Frame::data(first_frame.unwrap())));
+            let initial_frame = tokio_stream::once(Ok(Frame::data(Bytes::from(first_frame))));
             let frame_stream = unfold(
                 (ReceiverStream::new(receiver), shutdown_rx),
                 |(mut receiver, mut shutdown_rx)| async move {
                     if let RunningPhase::ShutdownPending = *shutdown_rx.borrow() {
-                        warn!("Disconnecting streaming client.");
                         return None;
                     }
                     loop {
                         tokio::select! {
                             maybe_bytes = receiver.next() => {
-                                if let Some(bytes) = maybe_bytes {
-                                    // We assume `bytes` is Some(Bytes) here.
-                                    return Some((Ok(Frame::data(bytes.unwrap())), (receiver, shutdown_rx)));
-                                } else {
-                                    // Receiver closed, end the stream.
-                                    return None;
+                              match maybe_bytes {
+                                Some(ByteFrame::Data(bytes)) | Some(ByteFrame::End(bytes)) => {
+                                  return Some((Ok(Frame::data(bytes)), (receiver, shutdown_rx)));
                                 }
+                                _ => {
+                                  return None;
+                                }
+                              }
                             },
                             _ = shutdown_rx.changed() => {
                                 match *shutdown_rx.borrow() {
@@ -185,7 +185,7 @@ impl ItsiResponse {
         Ok((headers, status, requires_upgrade, reader))
     }
 
-    pub async fn process_hijacked_response(&self) -> Result<Response<BoxBody<Bytes, Infallible>>> {
+    pub async fn process_hijacked_response(&self) -> Result<HttpResponse> {
         let (headers, status, requires_upgrade, reader) = self.read_hijacked_headers().await?;
         let mut response = if requires_upgrade {
             let parts = self.data.parts.clone();
@@ -262,27 +262,31 @@ impl ItsiResponse {
         }
     }
 
-    pub fn send_frame(&self, frame: Bytes) -> MagnusResult<usize> {
-        self.send_frame_into(frame, &self.data.response_writer)
+    pub fn send_frame(&self, frame: Bytes) -> MagnusResult<()> {
+        self.send_frame_into(ByteFrame::Data(frame), &self.data.response_writer)
     }
 
-    pub fn send_and_close(&self, frame: Bytes) -> MagnusResult<usize> {
-        let result = self.send_frame_into(frame, &self.data.response_writer);
+    pub fn recv_frame(&self) {
+        // not implemented
+    }
+
+    pub fn send_and_close(&self, frame: Bytes) -> MagnusResult<()> {
+        let result = self.send_frame_into(ByteFrame::End(frame), &self.data.response_writer);
         self.data.response_writer.write().take();
         result
     }
 
     pub fn send_frame_into(
         &self,
-        frame: Bytes,
-        writer: &RwLock<Option<mpsc::Sender<Option<Bytes>>>>,
-    ) -> MagnusResult<usize> {
+        frame: ByteFrame,
+        writer: &RwLock<Option<mpsc::Sender<ByteFrame>>>,
+    ) -> MagnusResult<()> {
         if let Some(writer) = writer.write().as_ref() {
-            writer
-                .blocking_send(Some(frame))
-                .map_err(|_| itsi_error::ItsiError::ClientConnectionClosed)?;
+            return Ok(writer
+                .blocking_send(frame)
+                .map_err(|_| itsi_error::ItsiError::ClientConnectionClosed)?);
         }
-        Ok(0)
+        Ok(())
     }
 
     pub fn is_hijacked(&self) -> bool {
@@ -293,20 +297,28 @@ impl ItsiResponse {
         self.data.response_writer.write().take();
         Ok(true)
     }
+    fn accept_str(&self) -> &str {
+        self.data
+            .parts
+            .headers
+            .get("Content-Type")
+            .and_then(|hv| hv.to_str().ok()) // handle invalid utf-8
+            .unwrap_or("application/x-www-form-urlencoded")
+    }
 
     pub fn is_html(&self) -> bool {
-        self.accept.starts_with("text/html")
+        self.accept_str().starts_with("text/html")
     }
 
     pub fn is_json(&self) -> bool {
-        self.accept.starts_with("application/json")
+        self.accept_str().starts_with("application/json")
     }
 
     pub fn close_read(&self) -> MagnusResult<bool> {
         Ok(true)
     }
 
-    pub fn new(parts: Parts, response_writer: mpsc::Sender<Option<Bytes>>, accept: String) -> Self {
+    pub fn new(parts: Parts, response_writer: mpsc::Sender<ByteFrame>) -> Self {
         Self {
             data: Arc::new(ResponseData {
                 response: RwLock::new(Some(Response::new(BoxBody::new(Empty::new())))),
@@ -315,7 +327,6 @@ impl ItsiResponse {
                 hijacked_socket: RwLock::new(None),
                 parts,
             }),
-            accept,
         }
     }
 
@@ -330,6 +341,26 @@ impl ItsiResponse {
         Ok(())
     }
 
+    pub fn add_headers(&self, headers: HashMap<Bytes, Vec<Bytes>>) -> MagnusResult<()> {
+        if let Some(ref mut resp) = *self.data.response.write() {
+            let headers_mut = resp.headers_mut();
+            for (name, values) in headers {
+                let header_name = HeaderName::from_bytes(&name).map_err(|e| {
+                    itsi_error::ItsiError::InvalidInput(format!(
+                        "Invalid header name {:?}: {:?}",
+                        name, e
+                    ))
+                })?;
+                for value in values {
+                    let header_value = unsafe { HeaderValue::from_maybe_shared_unchecked(value) };
+                    headers_mut.insert(&header_name, header_value);
+                }
+            }
+        }
+
+        Ok(())
+    }
+
     pub fn set_status(&self, status: u16) -> MagnusResult<()> {
         if let Some(ref mut resp) = *self.data.response.write() {
             *resp.status_mut() = StatusCode::from_u16(status).map_err(|e| {
@@ -348,8 +379,8 @@ impl ItsiResponse {
         *self.data.hijacked_socket.write() = Some(stream);
         if let Some(writer) = self.data.response_writer.write().as_ref() {
             writer
-                .blocking_send(None)
-                .map_err(|_| itsi_error::ItsiError::ClientConnectionClosed)?;
+                .blocking_send(ByteFrame::Empty)
+                .map_err(|_| itsi_error::ItsiError::ClientConnectionClosed)?
         }
         self.close();
         Ok(())

data/crates/itsi_server/src/ruby_types/itsi_server/file_watcher.rs

@@ -0,0 +1,225 @@
+use derive_more::Debug;
+use globset::{Glob, GlobSet, GlobSetBuilder};
+use magnus::error::Result;
+use nix::unistd::{close, fork, pipe, read};
+use notify::{event::ModifyKind, EventKind, RecommendedWatcher};
+use notify::{Event, RecursiveMode, Watcher};
+use std::path::Path;
+use std::sync::mpsc::Sender;
+use std::time::{Duration, Instant};
+use std::{collections::HashSet, fs};
+use std::{
+    os::fd::{AsRawFd, IntoRawFd, OwnedFd},
+    path::PathBuf,
+    process::Command,
+    sync::mpsc,
+    thread::{self},
+};
+
+/// Represents a set of patterns and commands.
+#[derive(Debug, Clone)]
+struct PatternGroup {
+    base_dir: PathBuf,
+    glob_set: GlobSet,
+    pattern: String,
+    commands: Vec<Vec<String>>,
+    last_triggered: Option<Instant>,
+}
+
+/// Extracts the base directory from a wildcard pattern by taking the portion up to the first
+/// component that contains a wildcard character.
+fn extract_and_canonicalize_base_dir(pattern: &str) -> PathBuf {
+    if !(pattern.contains("*") || pattern.contains("?") || pattern.contains('[')) {
+        if let Ok(metadata) = fs::metadata(pattern) {
+            if metadata.is_dir() {
+                return fs::canonicalize(pattern).unwrap();
+            }
+            if metadata.is_file() {
+                return fs::canonicalize(pattern)
+                    .unwrap()
+                    .parent()
+                    .unwrap()
+                    .to_path_buf();
+            }
+        }
+    }
+
+    let path = Path::new(pattern);
+    let mut base = PathBuf::new();
+    for comp in path.components() {
+        let comp_str = comp.as_os_str().to_string_lossy();
+        if comp_str.contains('*') || comp_str.contains('?') || comp_str.contains('[') {
+            break;
+        } else {
+            base.push(comp);
+        }
+    }
+    // If no base was built, default to "."
+    let base = if base.as_os_str().is_empty() || !base.exists() {
+        PathBuf::from(".")
+    } else {
+        base
+    };
+
+    // Canonicalize to get the absolute path.
+    fs::canonicalize(&base).unwrap_or(base)
+}
+
+/// Minimum time between triggering the same pattern group (debounce time)
+const DEBOUNCE_DURATION: Duration = Duration::from_millis(500);
+
+pub fn watch_groups(pattern_groups: Vec<(String, Vec<Vec<String>>)>) -> Result<Option<OwnedFd>> {
+    let (r_fd, w_fd): (OwnedFd, OwnedFd) = pipe().map_err(|e| {
+        magnus::Error::new(
+            magnus::exception::exception(),
+            format!("Failed to create watcher pipe: {}", e),
+        )
+    })?;
+
+    let fork_result = unsafe {
+        fork().map_err(|e| {
+            magnus::Error::new(
+                magnus::exception::exception(),
+                format!("Failed to fork file watcher: {}", e),
+            )
+        })
+    }?;
+
+    if fork_result.is_child() {
+        let _ = close(w_fd.into_raw_fd());
+        thread::spawn(move || {
+            let mut buf = [0u8; 1];
+            loop {
+                match read(r_fd.as_raw_fd(), &mut buf) {
+                    Ok(0) => {
+                        std::process::exit(0);
+                    }
+                    Ok(_) => {}
+                    Err(_) => {
+                        std::process::exit(0);
+                    }
+                }
+            }
+        });
+
+        let mut groups = Vec::new();
+        for (pattern, commands) in pattern_groups.into_iter() {
+            let base_dir = extract_and_canonicalize_base_dir(&pattern);
+            let glob = Glob::new(&pattern).map_err(|e| {
+                magnus::Error::new(
+                    magnus::exception::exception(),
+                    format!("Failed to create watch glob: {}", e),
+                )
+            })?;
+            let glob_set = GlobSetBuilder::new().add(glob).build().map_err(|e| {
+                magnus::Error::new(
+                    magnus::exception::exception(),
+                    format!("Failed to create watch glob set: {}", e),
+                )
+            })?;
+            groups.push(PatternGroup {
+                base_dir,
+                glob_set,
+                pattern,
+                commands,
+                last_triggered: None,
+            });
+        }
+
+        // Create a channel and a watcher.
+        let (tx, rx) = mpsc::channel::<notify::Result<Event>>();
+        let sender = tx.clone();
+        fn event_fn(sender: Sender<notify::Result<Event>>) -> impl Fn(notify::Result<Event>) {
+            move |res| match res {
+                Ok(event) => {
+                    sender.send(Ok(event)).unwrap();
+                }
+                Err(e) => println!("watch error: {:?}", e),
+            }
+        }
+
+        let mut watched_dirs = HashSet::new();
+        let mut watcher: RecommendedWatcher =
+            notify::recommended_watcher(event_fn(sender)).expect("Failed to create watcher");
+        for group in &groups {
+            if watched_dirs.insert(group.base_dir.clone()) {
+                watcher
+                    .watch(&group.base_dir, RecursiveMode::Recursive)
+                    .expect("Failed to add watch");
+            }
+        }
+
+        // Main event loop.
+        for res in rx {
+            match res {
+                Ok(event) => {
+                    if !matches!(event.kind, EventKind::Modify(ModifyKind::Metadata(_))) {
+                        continue;
+                    }
+                    let now = Instant::now();
+                    for group in &mut groups {
+                        for path in event.paths.iter() {
+                            if let Ok(rel_path) = path.strip_prefix(&group.base_dir) {
+                                if group.glob_set.is_match(rel_path)
+                                    || rel_path.to_str().is_some_and(|s| s == group.pattern)
+                                {
+                                    // Check if we should debounce this event
+                                    if let Some(last_triggered) = group.last_triggered {
+                                        if now.duration_since(last_triggered) < DEBOUNCE_DURATION {
+                                            // Skip this event as we've recently triggered for this pattern
+                                            continue;
+                                        }
+                                    }
+
+                                    // Update the last triggered time
+                                    group.last_triggered = Some(now);
+
+                                    // Execute the commands for this group.
+                                    for command in &group.commands {
+                                        if command.is_empty() {
+                                            continue;
+                                        }
+                                        let mut cmd = Command::new(&command[0]);
+                                        if command.len() > 1 {
+                                            cmd.args(&command[1..]);
+                                        }
+                                        match cmd.spawn() {
+                                            Ok(mut child) => {
+                                                if let Err(e) = child.wait() {
+                                                    eprintln!(
+                                                        "Command {:?} failed: {:?}",
+                                                        command, e
+                                                    );
+                                                }
+                                            }
+                                            Err(e) => {
+                                                eprintln!(
+                                                    "Failed to execute command {:?}: {:?}",
+                                                    command, e
+                                                );
+                                            }
+                                        }
+                                    }
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+                Err(e) => println!("Watch error: {:?}", e),
+            }
+        }
+
+        // Clean up the watches.
+        for group in &groups {
+            watcher
+                .unwatch(&group.base_dir)
+                .expect("Failed to remove watch");
+        }
+        drop(watcher);
+        std::process::exit(0);
+    } else {
+        let _ = close(r_fd.into_raw_fd());
+        Ok(Some(w_fd))
+    }
+}